ftp.mactech.com 2010/ftp.mactech.com.tar/ftp.mactech.com/thinkref/archive/THINKPascalUH2.1.sea/THINKPas Univ Hdr 2.1/Interfaces/GXPrinting.p

Text File | 1995-09-14 | 117KB | 3,647 lines

{ Converted with MPW2TPas Tuesday, September 12, 1995 7:02:30 PM }
{}
{     File:        GXPrinting.p}
{ }
{     Contains:    This file contains all printing APIs except for driver/extension specific ones.}
{ }
{     Version:    Technology:    Quickdraw GX 1.1}
{                 Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18}
{ }
{     Copyright:    © 1984-1995 by Apple Computer, Inc.}
{                 All rights reserved.}
{ }
{     Bugs?:        If you find a problem with this file, use the Apple Bug Reporter}
{                 stack.  Include the file and version information (from above)}
{                 in the problem description and send to:}
{                     Internet:    [e-mail]}
{                     AppleLink:    APPLE.BUGS}
{ }
{}

unit GXPrinting;
interface


{$IFC UNDEFINED __GXPRINTING__}
{$SETC __GXPRINTING__ := 1}

    uses
        ConditionalMacros, Types, Collections, Quickdraw, Dialogs, Errors, Files, GXFonts, GXMath, GXTypes, Controls, Lists, Menus, GXMessages, Printing, Quickdraw;

{ $PUSH}
{ $ALIGN MAC68K}
{ $LibExport+}

    const
        gestaltGXPrintingMgrVersion = 'pmgr';
        gestaltGXVersion = 'qdgx';


    type
        gxOwnerSignature = LONGINT;

{$IFC OLDROUTINENAMES }
        Signature = LONGINT;

{$ENDC}
        gxPrinter = Ptr;

        gxJob = Ptr;

        gxFormat = Ptr;

        gxPaperType = Ptr;

        gxPrintFile = Ptr;

        gxLoopStatus = BOOLEAN;


    const
        gxStopLooping = false;
        gxKeepLooping = true;

    type
        gxViewDeviceProcPtr = ProcPtr;  { FUNCTION gxViewDevice(aViewDevice: gxViewDevice; refCon: UNIV Ptr): gxLoopStatus; }
        gxViewDeviceUPP = UniversalProcPtr;

    const
        uppgxViewDeviceProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }

    function NewgxViewDeviceProc (userRoutine: gxViewDeviceProcPtr): gxViewDeviceUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallgxViewDeviceProc (aViewDevice: gxViewDevice; refCon: univ Ptr; userRoutine: gxViewDeviceUPP): gxLoopStatus;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}
    type
        gxFormatProcPtr = ProcPtr;  { FUNCTION gxFormat(aFormat: gxFormat; refCon: UNIV Ptr): gxLoopStatus; }
        gxFormatUPP = UniversalProcPtr;

    const
        uppgxFormatProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }

    function NewgxFormatProc (userRoutine: gxFormatProcPtr): gxFormatUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallgxFormatProc (aFormat: gxFormat; refCon: univ Ptr; userRoutine: gxFormatUPP): gxLoopStatus;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}
    type
        gxPaperTypeProcPtr = ProcPtr;  { FUNCTION gxPaperType(aPapertype: gxPaperType; refCon: UNIV Ptr): gxLoopStatus; }
        gxPaperTypeUPP = UniversalProcPtr;

    const
        uppgxPaperTypeProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }

    function NewgxPaperTypeProc (userRoutine: gxPaperTypeProcPtr): gxPaperTypeUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallgxPaperTypeProc (aPapertype: gxPaperType; refCon: univ Ptr; userRoutine: gxPaperTypeUPP): gxLoopStatus;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}
    type
        gxPrintingFlattenProcPtr = ProcPtr;  { FUNCTION gxPrintingFlatten(size: LONGINT; data: UNIV Ptr; refCon: UNIV Ptr): OSErr; }
        gxPrintingFlattenUPP = UniversalProcPtr;

    const
        uppgxPrintingFlattenProcInfo = $00000FE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewgxPrintingFlattenProc (userRoutine: gxPrintingFlattenProcPtr): gxPrintingFlattenUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallgxPrintingFlattenProc (size: LONGINT; data: univ Ptr; refCon: univ Ptr; userRoutine: gxPrintingFlattenUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        gxViewDeviceProc = gxViewDeviceUPP;

        gxFormatProc = gxFormatUPP;

        gxPaperTypeProc = gxPaperTypeUPP;

        gxPrintingFlattenProc = gxPrintingFlattenUPP;

{}
{    The following constants are used to set collection item flags in printing}
{    collections. The Printing Manager purges certain items whenever a driver}
{    switch occurs. If the formatting driver changes, all items marked as}
{    gxVolatileFormattingDriverCategory will be purged.  If the output driver}
{    changes, all items marked as gxVolatileOutputDriverCategory will be purged.}
{    Note that to prevent items from being flattened when GXFlattenJob is called,}
{    you should unset the collectionPersistenceBit (defined in Collections.h),}
{    which is on by default.}
{}
{ Structure stored in collection items' user attribute bits }
        gxCollectionCategory = INTEGER;


    const
        gxNoCollectionCategory = $0000;
        gxOutputDriverCategory = $0001;
        gxFormattingDriverCategory = $0002;
        gxDriverVolatileCategory = $0004;
        gxVolatileOutputDriverCategory = $5;
        gxVolatileFormattingDriverCategory = $6;

{}
{}
{    >>>>>> JOB COLLECTION ITEMS <<<<<<}
{}
{}
{ gxJobInfo COLLECTION ITEM }
        gxJobTag = 'job ';


    type
        gxJobInfo = record
                numPages: LONGINT;                                { Number of pages in the document }
                priority: LONGINT;                                { Priority of this job plus "is it on hold?" }
                timeToPrint: LONGINT;                                { When to print job, if scheduled }
                jobTimeout: LONGINT;                                { Timeout value, in ticks }
                firstPageToPrint: LONGINT;                                { Start printing from this page }
                jobAlert: INTEGER;                                { How to alert user when printing }
                appName: Str31;                                    { Which application printed the document }
                documentName: Str31;                                    { The name of the document being printed }
                userName: Str31;                                    { The owner name of the machine that printed the document }
            end;

{ priority field constants }

    const
        gxPrintJobHoldingBit = $00001000;                    { This bit is set if the job is on hold. }

        gxPrintJobUrgent = $00000001;
        gxPrintJobAtTime = $00000002;
        gxPrintJobASAP = $00000003;
        gxPrintJobHolding = $1003;
        gxPrintJobHoldingAtTime = $1002;
        gxPrintJobHoldingUrgent = $1001;

{ jobAlert field constants }
        gxNoPrintTimeAlert = 0;                            { Don't alert user when we print }
        gxAlertBefore = 1;                            { Alert user before we print }
        gxAlertAfter = 2;                            { Alert user after we print }
        gxAlertBothTimes = 3;                            { Alert before and after we print }

{ jobTimeout field constants }
        gxThirtySeconds = 1800;                            { 30 seconds in ticks }
        gxTwoMinutes = 7200;                            { 2 minutes in ticks }

{ gxCollationTag COLLECTION ITEM }
        gxCollationTag = 'sort';


    type
        gxCollationInfo = record
                collation: BOOLEAN;                                { True if copies are to be collated }
                padByte: CHAR;
            end;

{ gxCopiesTag COLLECTION ITEM }

    const
        gxCopiesTag = 'copy';


    type
        gxCopiesInfo = record
                copies: LONGINT;                                { Number of copies of the document to print }
            end;

{ gxPageRangeTag COLLECTION ITEM }

    const
        gxPageRangeTag = 'rang';


    type
        gxSimplePageRangeInfo = record
                optionChosen: CHAR;                                    { From options listed below }
                printAll: BOOLEAN;                                { True if user wants to print all pages }
                fromPage: LONGINT;                                { For gxDefaultPageRange, current value }
                toPage: LONGINT;                                { For gxDefaultPageRange, current value }
            end;

        gxPageRangeInfo = record
                simpleRange: gxSimplePageRangeInfo;                    { Info which will be returned for GetJobPageRange }
                fromString: Str31;                                    { For gxCustomizePageRange, current value }
                toString: Str31;                                    { For gxCustomizePageRange, current value }
                minFromPage: LONGINT;                                { For gxDefaultPageRange, we parse with this, ignored if nil }
                maxToPage: LONGINT;                                { For gxDefaultPageRange, we parse with this, ignored if nil }
                replaceString: array[0..0] of CHAR;                    { For gxReplacePageRange, string to display }
            end;

{ optionChosen field constants for SimplePageRangeInfo }

    const
        gxDefaultPageRange = 0;
        gxReplacePageRange = 1;
        gxCustomizePageRange = 2;

{ gxQualityTag COLLECTION ITEM }
        gxQualityTag = 'qual';


    type
        gxQualityInfo = record
                disableQuality: BOOLEAN;                                { True to disable standard quality controls }
                padByte: CHAR;
                defaultQuality: INTEGER;                                { The default quality value }
                currentQuality: INTEGER;                                { The current quality value }
                qualityCount: INTEGER;                                { The number of quality menu items in popup menu }
                qualityNames: array[0..0] of CHAR;                    { An array of packed pascal strings for popup menu titles }
            end;

{ gxFileDestinationTag COLLECTION ITEM }

    const
        gxFileDestinationTag = 'dest';


    type
        gxFileDestinationInfo = record
                toFile: BOOLEAN;                                { True if destination is a file }
                padByte: CHAR;
            end;

{ gxFileLocationTag COLLECTION ITEM }

    const
        gxFileLocationTag = 'floc';


    type
        gxFileLocationInfo = record
                fileSpec: FSSpec;                                    { Location to put file, if destination is file }
            end;

{ gxFileFormatTag COLLECTION ITEM }

    const
        gxFileFormatTag = 'ffmt';


    type
        gxFileFormatInfo = record
                fileFormatName: Str31;                                    { Name of file format (e.g. "PostScript") if destination is file }
            end;

{ gxFileFontsTag COLLECTION ITEM }

    const
        gxFileFontsTag = 'incf';


    type
        gxFileFontsInfo = record
                includeFonts: CHAR;                                    { Which fonts to include, if destination is file }
                padByte: CHAR;
            end;

{ includeFonts field constants }

    const
        gxIncludeNoFonts = 1;                            { Include no fonts }
        gxIncludeAllFonts = 2;                            { Include all fonts }
        gxIncludeNonStandardFonts = 3;                            { Include only fonts that aren't in the standard LW set }

{ gxPaperFeedTag COLLECTION ITEM }
        gxPaperFeedTag = 'feed';


    type
        gxPaperFeedInfo = record
                autoFeed: BOOLEAN;                                { True if automatic feed, false if manual }
                padByte: CHAR;
            end;

{ gxTrayFeedTag COLLECTION ITEM }

    const
        gxTrayFeedTag = 'tray';


    type
        gxTrayIndex = LONGINT;

        gxTrayFeedInfo = record
                feedTrayIndex: gxTrayIndex;                            { Tray to feed paper from }
                manualFeedThisPage: BOOLEAN;                                { Signals manual feeding for the page }
                padByte: CHAR;
            end;

{ gxManualFeedTag COLLECTION ITEM }

    const
        gxManualFeedTag = 'manf';


    type
        gxManualFeedInfo = record
                numPaperTypeNames: LONGINT;                                { Number of paperTypes to manually feed }
                paperTypeNames: array[0..0] of Str31;                    { Array of names of paperTypes to manually feed }
            end;

{ gxNormalMappingTag COLLECTION ITEM }

    const
        gxNormalMappingTag = 'nmap';


    type
        gxNormalMappingInfo = record
                normalPaperMapping: BOOLEAN;                                { True if not overriding normal paper mapping }
                padByte: CHAR;
            end;

{ gxSpecialMappingTag COLLECTION ITEM }

    const
        gxSpecialMappingTag = 'smap';


    type
        gxSpecialMappingInfo = record
                specialMapping: CHAR;                                    { Enumerated redirect, scale or tile setting }
                padByte: CHAR;
            end;

{ specialMapping field constants }

    const
        gxRedirectPages = 1;                            { Redirect pages to a papertype and clip if necessary }
        gxScalePages = 2;                            { Scale pages if necessary }
        gxTilePages = 3;                            { Tile pages if necessary }

{ gxTrayMappingTag COLLECTION ITEM }
        gxTrayMappingTag = 'tmap';


    type
        gxTrayMappingInfo = record
                mapPaperToTray: gxTrayIndex;                            { Tray to map all paper to }
            end;

{ gxPaperMappingTag COLLECTION ITEM }
{ This collection item contains a flattened paper type resource }

    const
        gxPaperMappingTag = 'pmap';

{ gxPrintPanelTag COLLECTION ITEM }
        gxPrintPanelTag = 'ppan';


    type
        gxPrintPanelInfo = record
                startPanelName: Str31;                                    { Name of starting panel in Print dialog }
            end;

{ gxFormatPanelTag COLLECTION ITEM }

    const
        gxFormatPanelTag = 'fpan';


    type
        gxFormatPanelInfo = record
                startPanelName: Str31;                                    { Name of starting panel in Format dialog }
            end;

{ gxTranslatedDocumentTag COLLECTION ITEM }

    const
        gxTranslatedDocumentTag = 'trns';


    type
        gxTranslatedDocumentInfo = record
                translatorInfo: LONGINT;                                { Information from the translation process }
            end;

{}
{}
{    >>>>>> FORMAT COLLECTION ITEMS <<<<<<}
{}
{}
{ gxPaperTypeLockTag COLLECTION ITEM }

    const
        gxPaperTypeLockTag = 'ptlk';


    type
        gxPaperTypeLockInfo = record
                paperTypeLocked: BOOLEAN;                                { True if format's paperType is locked }
                padByte: CHAR;
            end;

{ gxOrientationTag COLLECTION ITEM }

    const
        gxOrientationTag = 'layo';


    type
        gxOrientationInfo = record
                orientation: CHAR;                                    { An enumerated orientation value }
                padByte: CHAR;
            end;

{ orientation field constants }

    const
        gxPortraitLayout = 0;                            { Portrait }
        gxLandscapeLayout = 1;                            { Landscape }
        gxRotatedPortraitLayout = 2;                            { Portrait, rotated 180° }
        gxRotatedLandscapeLayout = 3;                            { Landscape, rotated 180°  }

{ gxScalingTag COLLECTION ITEM }
        gxScalingTag = 'scal';


    type
        gxScalingInfo = record
                horizontalScaleFactor: Fixed;                                    { Current horizontal scaling factor }
                verticalScaleFactor: Fixed;                                    { Current vertical scaling factor }
                minScaling: INTEGER;                                { Minimum scaling allowed }
                maxScaling: INTEGER;                                { Maximum scaling allowed }
            end;

{ gxDirectModeTag COLLECTION ITEM }

    const
        gxDirectModeTag = 'dirm';


    type
        gxDirectModeInfo = record
                directModeOn: BOOLEAN;                                { True if a direct mode is enabled }
                padByte: CHAR;
            end;

{ gxFormatHalftoneTag COLLECTION ITEM }

    const
        gxFormatHalftoneTag = 'half';


    type
        gxFormatHalftoneInfo = record
                numHalftones: LONGINT;                                { Number of halftone records }
                halftones: array[0..0] of gxHalftone;                { The halftone records }
            end;

{ gxInvertPageTag COLLECTION ITEM }

    const
        gxInvertPageTag = 'invp';


    type
        gxInvertPageInfo = record
                padByte: CHAR;
                invert: BOOLEAN;                                { If true, invert page }
            end;

{ gxFlipPageHorizontalTag COLLECTION ITEM }

    const
        gxFlipPageHorizontalTag = 'flph';


    type
        gxFlipPageHorizontalInfo = record
                padByte: CHAR;
                flipHorizontal: BOOLEAN;                                { If true, flip x coordinates on page }
            end;

{ gxFlipPageVerticalTag COLLECTION ITEM }

    const
        gxFlipPageVerticalTag = 'flpv';


    type
        gxFlipPageVerticalInfo = record
                padByte: CHAR;
                flipVertical: BOOLEAN;                                { If true, flip y coordinates on page }
            end;

{ gxPreciseBitmapsTag COLLECTION ITEM }

    const
        gxPreciseBitmapsTag = 'pbmp';


    type
        gxPreciseBitmapInfo = record
                preciseBitmaps: BOOLEAN;                                { If true, scale page by 96% }
                padByte: CHAR;
            end;

{}
{}
{    >>>>>> PAPERTYPE COLLECTION ITEMS <<<<<<}
{}
{}
{ gxBaseTag COLLECTION ITEM }

    const
        gxBaseTag = 'base';


    type
        gxBaseInfo = record
                baseType: LONGINT;                                { PaperType's base type }
            end;

{ baseType field constants }

    const
        gxUnknownBase = 0;                            { Base paper type from which this paper type is }
        gxUSLetterBase = 1;                            { derived.  This is not a complete set. }
        gxUSLegalBase = 2;
        gxA4LetterBase = 3;
        gxB5LetterBase = 4;
        gxTabloidBase = 5;

{ gxCreatorTag COLLECTION ITEM }
        gxCreatorTag = 'crea';


    type
        gxCreatorInfo = record
                creator: OSType;                                    { PaperType's creator }
            end;

{ gxUnitsTag COLLECTION ITEM }

    const
        gxUnitsTag = 'unit';


    type
        gxUnitsInfo = record
                units: CHAR;                                    { PaperType's units (used by PaperType Editor). }
                padByte: CHAR;
            end;

{ units field constants }

    const
        gxPicas = 0;                            { Pica measurement }
        gxMMs = 1;                            { Millimeter measurement }
        gxInches = 2;                            { Inches measurement }

{ gxFlagsTag COLLECTION ITEM }
        gxFlagsTag = 'flag';


    type
        gxFlagsInfo = record
                flags: LONGINT;                                { PaperType's flags }
            end;

{ flags field constants }

    const
        gxOldPaperTypeFlag = $00800000;                    { Indicates a paper type for compatibility printing }
        gxNewPaperTypeFlag = $00400000;                    { Indicates a paper type for QuickDraw GX-aware printing }
        gxOldAndNewFlag = $00C00000;                    { Indicates a paper type that's both old and new }
        gxDefaultPaperTypeFlag = $00100000;                    { Indicates the default paper type in the group }

{ gxCommentTag COLLECTION ITEM }
        gxCommentTag = 'cmnt';


    type
        gxCommentInfo = record
                comment: Str255;                                    { PaperType's comment }
            end;

{}
{}
{    >>>>>> PRINTER VIEWDEVICE TAGS <<<<<<}
{}
{}
{ gxPenTableTag COLLECTION ITEM }

    const
        gxPenTableTag = 'pent';


    type
        gxPenTableEntry = record
                penName: Str31;                                    { Name of the pen }
                penColor: gxColor;                                { Color to use from the color set }
                penThickness: Fixed;                                    { Size of the pen }
                penUnits: INTEGER;                                { Specifies units in which pen thickness is defined }
                penPosition: INTEGER;                                { Pen position in the carousel, -1 (kPenNotLoaded) if not loaded }
            end;

        gxPenTable = record
                numPens: LONGINT;                                { Number of pen entries in the following array }
                pens: array[0..0] of gxPenTableEntry;        { Array of pen entries }
            end;

        gxPenTablePtr = ^gxPenTable;
        gxPenTableHdl = ^gxPenTablePtr;

{ penUnits field constants }

    const
        gxDeviceUnits = 0;
        gxMMUnits = 1;
        gxInchesUnits = 2;

{ penPosition field constants }
        gxPenNotLoaded = -1;

{}
{}
{    >>>>>> DIALOG-RELATED CONSTANTS AND TYPES <<<<<<}
{}
{}

    type
        gxDialogResult = LONGINT;


    const
        gxCancelSelected = 0;
        gxOKSelected = 1;
        gxRevertSelected = 2;


    type
        gxEditMenuRecord = record
                editMenuID: INTEGER;
                cutItem: INTEGER;
                copyItem: INTEGER;
                pasteItem: INTEGER;
                clearItem: INTEGER;
                undoItem: INTEGER;
            end;

{}
{}
{    >>>>>> JOB FORMAT MODE CONSTANTS AND TYPES <<<<<<}
{}
{}
        gxJobFormatMode = OSType;

        gxJobFormatModeTable = record
                numModes: LONGINT;                                { Number of job format modes to choose from }
                modes: array[0..0] of gxJobFormatMode;        { The job format modes }
            end;

        gxJobFormatModeTablePtr = ^gxJobFormatModeTable;
        gxJobFormatModeTableHdl = ^gxJobFormatModeTablePtr;


    const
        gxGraphicsJobFormatMode = 'grph';
        gxTextJobFormatMode = 'text';
        gxPostScriptJobFormatMode = 'post';


    type
        gxQueryType = LONGINT;


    const
        gxGetJobFormatLineConstraintQuery = 0;
        gxGetJobFormatFontsQuery = 1;
        gxGetJobFormatFontCommonStylesQuery = 2;
        gxGetJobFormatFontConstraintQuery = 3;
        gxSetStyleJobFormatCommonStyleQuery = 4;

{ Structures used for Text mode field constants }

    type
        gxPositionConstraintTable = record
                phase: gxPoint;                                { Position phase }
                offset: gxPoint;                                { Position offset }
                numSizes: LONGINT;                                { Number of available font sizes }
                sizes: array[0..0] of Fixed;                    { The available font sizes }
            end;

        gxPositionConstraintTablePtr = ^gxPositionConstraintTable;
        gxPositionConstraintTableHdl = ^gxPositionConstraintTablePtr;

{ numSizes field constants }

    const
        gxConstraintRange = -1;


    type
        gxStyleNameTable = record
                numStyleNames: LONGINT;                                { Number of style names }
                styleNames: array[0..0] of Str255;                    { The style names }
            end;

        gxStyleNameTablePtr = ^gxStyleNameTable;
        gxStyleNameTableHdl = ^gxStyleNameTablePtr;

        gxFontTable = record
                numFonts: LONGINT;                                { Number of font references }
                fonts: array[0..0] of gxFont;                    { The font references }
            end;

        gxFontTablePtr = ^gxFontTable;
        gxFontTableHdl = ^gxFontTablePtr;

{ ------------------------------------------------------------------------------}
{}
{                                Printing Manager API Functions}
{}
{-------------------------------------------------------------------------------- }

    function GXInitPrinting: OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 0, $ABFE;
    {$ENDC}
    function GXExitPrinting: OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 1, $ABFE;
    {$ENDC}
{}
{    Error-Handling Routines}
{}
    function GXGetJobError (aJob: gxJob): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 14, $ABFE;
    {$ENDC}
    procedure GXSetJobError (aJob: gxJob; anErr: OSErr);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 15, $ABFE;
    {$ENDC}
{}
{    Job Routines}
{}
    function GXNewJob (var aJob: gxJob): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 2, $ABFE;
    {$ENDC}
    function GXDisposeJob (aJob: gxJob): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 3, $ABFE;
    {$ENDC}
    procedure GXFlattenJob (aJob: gxJob; flattenProc: gxPrintingFlattenProc; aVoid: univ Ptr);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 4, $ABFE;
    {$ENDC}
    function GXUnflattenJob (aJob: gxJob; flattenProc: gxPrintingFlattenProc; aVoid: univ Ptr): gxJob;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 5, $ABFE;
    {$ENDC}
    function GXFlattenJobToHdl (aJob: gxJob; aHdl: Handle): Handle;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 6, $ABFE;
    {$ENDC}
    function GXUnflattenJobFromHdl (aJob: gxJob; aHdl: Handle): gxJob;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 7, $ABFE;
    {$ENDC}
    procedure GXInstallApplicationOverride (aJob: gxJob; messageID: INTEGER; override: univ Ptr);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 8, $ABFE;
    {$ENDC}
    function GXGetJobCollection (aJob: gxJob): Collection;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 29, $ABFE;
    {$ENDC}
    function GXGetJobRefCon (aJob: gxJob): Ptr;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 30, $ABFE;
    {$ENDC}
    procedure GXSetJobRefCon (aJob: gxJob; refCon: univ Ptr);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 31, $ABFE;
    {$ENDC}
    function GXCopyJob (srcJob: gxJob; dstJob: gxJob): gxJob;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 32, $ABFE;
    {$ENDC}
    procedure GXSelectJobFormattingPrinter (aJob: gxJob; var printerName: Str31);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 33, $ABFE;
    {$ENDC}
    procedure GXSelectJobOutputPrinter (aJob: gxJob; var printerName: Str31);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 34, $ABFE;
    {$ENDC}
    procedure GXForEachJobFormatDo (aJob: gxJob; formatProc: gxFormatProc; refCon: univ Ptr);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 35, $ABFE;
    {$ENDC}
    function GXCountJobFormats (aJob: gxJob): LONGINT;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 36, $ABFE;
    {$ENDC}
    function GXUpdateJob (aJob: gxJob): BOOLEAN;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 37, $ABFE;
    {$ENDC}
    procedure GXConvertPrintRecord (aJob: gxJob; hPrint: THPrint);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 38, $ABFE;
    {$ENDC}
    procedure GXIdleJob (aJob: gxJob);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 87, $ABFE;
    {$ENDC}
{}
{    Job Format Modes Routines}
{}
    procedure GXSetAvailableJobFormatModes (aJob: gxJob; formatModeTable: gxJobFormatModeTableHdl);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 59, $ABFE;
    {$ENDC}
    function GXGetPreferredJobFormatMode (aJob: gxJob; var directOnly: BOOLEAN): gxJobFormatMode;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 60, $ABFE;
    {$ENDC}
    function GXGetJobFormatMode (aJob: gxJob): gxJobFormatMode;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 61, $ABFE;
    {$ENDC}
    procedure GXSetJobFormatMode (aJob: gxJob; formatMode: gxJobFormatMode);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 62, $ABFE;
    {$ENDC}
    procedure GXJobFormatModeQuery (aJob: gxJob; aQueryType: gxQueryType; srcData: univ Ptr; dstData: univ Ptr);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 63, $ABFE;
    {$ENDC}
{}
{    Format Routines}
{}
    function GXNewFormat (aJob: gxJob): gxFormat;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 9, $ABFE;
    {$ENDC}
    procedure GXDisposeFormat (aFormat: gxFormat);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 10, $ABFE;
    {$ENDC}
    function GXGetJobFormat (aJob: gxJob; whichFormat: LONGINT): gxFormat;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 19, $ABFE;
    {$ENDC}
    function GXGetFormatJob (aFormat: gxFormat): gxJob;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 20, $ABFE;
    {$ENDC}
    function GXGetFormatPaperType (aFormat: gxFormat): gxPaperType;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 21, $ABFE;
    {$ENDC}
    procedure GXGetFormatDimensions (aFormat: gxFormat; var pageSize: gxRectangle; var paperSize: gxRectangle);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 22, $ABFE;
    {$ENDC}
    function GXGetFormatCollection (aFormat: gxFormat): Collection;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 51, $ABFE;
    {$ENDC}
    procedure GXChangedFormat (aFormat: gxFormat);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 52, $ABFE;
    {$ENDC}
    function GXCopyFormat (srcFormat: gxFormat; dstFormat: gxFormat): gxFormat;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 53, $ABFE;
    {$ENDC}
    function GXCloneFormat (aFormat: gxFormat): gxFormat;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 54, $ABFE;
    {$ENDC}
    function GXCountFormatOwners (aFormat: gxFormat): LONGINT;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 55, $ABFE;
    {$ENDC}
    procedure GXGetFormatMapping (aFormat: gxFormat; var fmtMapping: gxMapping);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 56, $ABFE;
    {$ENDC}
    function GXGetFormatForm (aFormat: gxFormat; var mask: gxShape): gxShape;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 57, $ABFE;
    {$ENDC}
    procedure GXSetFormatForm (aFormat: gxFormat; form: gxShape; mask: gxShape);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 58, $ABFE;
    {$ENDC}
{}
{    PaperType Routines}
{}
    function GXNewPaperType (aJob: gxJob; var name: Str31; var pageSize: gxRectangle; var paperSize: gxRectangle): gxPaperType;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 11, $ABFE;
    {$ENDC}
    procedure GXDisposePaperType (aPaperType: gxPaperType);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 12, $ABFE;
    {$ENDC}
    function GXGetNewPaperType (aJob: gxJob; resID: INTEGER): gxPaperType;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 13, $ABFE;
    {$ENDC}
    function GXCountJobPaperTypes (aJob: gxJob; forFormatDevice: BOOLEAN): LONGINT;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 66, $ABFE;
    {$ENDC}
    function GXGetJobPaperType (aJob: gxJob; whichPaperType: LONGINT; forFormatDevice: BOOLEAN; aPaperType: gxPaperType): gxPaperType;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 67, $ABFE;
    {$ENDC}
    procedure GXForEachJobPaperTypeDo (aJob: gxJob; aProc: gxPaperTypeProc; refCon: univ Ptr; forFormattingPrinter: BOOLEAN);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 68, $ABFE;
    {$ENDC}
    function GXCopyPaperType (srcPaperType: gxPaperType; dstPaperType: gxPaperType): gxPaperType;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 69, $ABFE;
    {$ENDC}
    procedure GXGetPaperTypeName (aPaperType: gxPaperType; var papertypeName: Str31);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 70, $ABFE;
    {$ENDC}
    procedure GXGetPaperTypeDimensions (aPaperType: gxPaperType; var pageSize: gxRectangle; var paperSize: gxRectangle);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 71, $ABFE;
    {$ENDC}
    function GXGetPaperTypeJob (aPaperType: gxPaperType): gxJob;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 72, $ABFE;
    {$ENDC}
    function GXGetPaperTypeCollection (aPaperType: gxPaperType): Collection;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 73, $ABFE;
    {$ENDC}
{}
{    Printer Routines}
{}
    function GXGetJobFormattingPrinter (aJob: gxJob): gxPrinter;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 39, $ABFE;
    {$ENDC}
    function GXGetJobOutputPrinter (aJob: gxJob): gxPrinter;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 40, $ABFE;
    {$ENDC}
    function GXGetJobPrinter (aJob: gxJob): gxPrinter;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 41, $ABFE;
    {$ENDC}
    function GXGetPrinterJob (aPrinter: gxPrinter): gxJob;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 42, $ABFE;
    {$ENDC}
    procedure GXForEachPrinterViewDeviceDo (aPrinter: gxPrinter; aProc: gxViewDeviceProc; refCon: univ Ptr);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 43, $ABFE;
    {$ENDC}
    function GXCountPrinterViewDevices (aPrinter: gxPrinter): LONGINT;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 44, $ABFE;
    {$ENDC}
    function GXGetPrinterViewDevice (aPrinter: gxPrinter; whichViewDevice: LONGINT): gxViewDevice;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 45, $ABFE;
    {$ENDC}
    procedure GXSelectPrinterViewDevice (aPrinter: gxPrinter; whichViewDevice: LONGINT);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 46, $ABFE;
    {$ENDC}
    procedure GXGetPrinterName (aPrinter: gxPrinter; var printerName: Str31);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 47, $ABFE;
    {$ENDC}
    function GXGetPrinterType (aPrinter: gxPrinter): OSType;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 48, $ABFE;
    {$ENDC}
    procedure GXGetPrinterDriverName (aPrinter: gxPrinter; var driverName: Str31);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 49, $ABFE;
    {$ENDC}
    function GXGetPrinterDriverType (aPrinter: gxPrinter): OSType;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 50, $ABFE;
    {$ENDC}
{}
{    Dialog Routines}
{}
    function GXJobDefaultFormatDialog (aJob: gxJob; var anEditMenuRec: gxEditMenuRecord): gxDialogResult;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 16, $ABFE;
    {$ENDC}
    function GXJobPrintDialog (aJob: gxJob; var anEditMenuRec: gxEditMenuRecord): gxDialogResult;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 17, $ABFE;
    {$ENDC}
    function GXFormatDialog (aFormat: gxFormat; var anEditMenuRec: gxEditMenuRecord; title: StringPtr): gxDialogResult;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 18, $ABFE;
    {$ENDC}
    procedure GXEnableJobScalingPanel (aJob: gxJob; enabled: BOOLEAN);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 64, $ABFE;
    {$ENDC}
    procedure GXGetJobPanelDimensions (aJob: gxJob; var panelArea: Rect);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 65, $ABFE;
    {$ENDC}
{}
{    Spooling Routines}
{}
    procedure GXGetJobPageRange (theJob: gxJob; var firstPage: LONGINT; var lastPage: LONGINT);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 23, $ABFE;
    {$ENDC}
    procedure GXStartJob (theJob: gxJob; docName: StringPtr; pageCount: LONGINT);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 24, $ABFE;
    {$ENDC}
    procedure GXPrintPage (theJob: gxJob; pageNumber: LONGINT; theFormat: gxFormat; thePage: gxShape);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 25, $ABFE;
    {$ENDC}
    function GXStartPage (theJob: gxJob; pageNumber: LONGINT; theFormat: gxFormat; numViewPorts: LONGINT; var viewPortList: gxViewPort): BOOLEAN;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 26, $ABFE;
    {$ENDC}
    procedure GXFinishPage (theJob: gxJob);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 27, $ABFE;
    {$ENDC}
    procedure GXFinishJob (theJob: gxJob);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 28, $ABFE;
    {$ENDC}
{}
{    PrintFile Routines}
{}
    function GXOpenPrintFile (theJob: gxJob; anFSSpec: FSSpecPtr; permission: ByteParameter): gxPrintFile;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 74, $ABFE;
    {$ENDC}
    procedure GXClosePrintFile (aPrintFile: gxPrintFile);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 75, $ABFE;
    {$ENDC}
    function GXGetPrintFileJob (aPrintFile: gxPrintFile): gxJob;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 76, $ABFE;
    {$ENDC}
    function GXCountPrintFilePages (aPrintFile: gxPrintFile): LONGINT;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 77, $ABFE;
    {$ENDC}
    procedure GXReadPrintFilePage (aPrintFile: gxPrintFile; pageNumber: LONGINT; numViewPorts: LONGINT; var viewPortList: gxViewPort; var pgFormat: gxFormat; var pgShape: gxShape);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 78, $ABFE;
    {$ENDC}
    procedure GXReplacePrintFilePage (aPrintFile: gxPrintFile; pageNumber: LONGINT; aFormat: gxFormat; aShape: gxShape);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 79, $ABFE;
    {$ENDC}
    procedure GXInsertPrintFilePage (aPrintFile: gxPrintFile; atPageNumber: LONGINT; pgFormat: gxFormat; pgShape: gxShape);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 80, $ABFE;
    {$ENDC}
    procedure GXDeletePrintFilePageRange (aPrintFile: gxPrintFile; fromPageNumber: LONGINT; toPageNumber: LONGINT);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 81, $ABFE;
    {$ENDC}
    procedure GXSavePrintFile (aPrintFile: gxPrintFile; var anFSSpec: FSSpec);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 82, $ABFE;
    {$ENDC}
{}
{    ColorSync Routines}
{}
    function GXFindPrinterProfile (aPrinter: gxPrinter; searchData: univ Ptr; index: LONGINT; var returnedProfile: gxColorProfile): LONGINT;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 83, $ABFE;
    {$ENDC}
    function GXFindFormatProfile (aFormat: gxFormat; searchData: univ Ptr; index: LONGINT; var returnedProfile: gxColorProfile): LONGINT;
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 84, $ABFE;
    {$ENDC}
    procedure GXSetPrinterProfile (aPrinter: gxPrinter; oldProfile: gxColorProfile; newProfile: gxColorProfile);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 85, $ABFE;
    {$ENDC}
    procedure GXSetFormatProfile (aFormat: gxFormat; oldProfile: gxColorProfile; newProfile: gxColorProfile);
    {$IFC NOT GENERATINGCFM}
    inline
        $203C, $0000, 86, $ABFE;
    {$ENDC}
{***********************************************************************}
{                        Start of old "GXPrintingResEquates.h/a/p" interface file.}
{                ************************************************************************}
{    ------------------------------------}
{                Basic client types}
{    ------------------------------------ }

    const
        gxPrintingManagerType = 'pmgr';
        gxImagingSystemType = 'gxis';
        gxPrinterDriverType = 'pdvr';
        gxPrintingExtensionType = 'pext';
        gxUnknownPrinterType = 'none';
        gxAnyPrinterType = 'univ';
        gxQuickdrawPrinterType = 'qdrw';
        gxPortableDocPrinterType = 'gxpd';
        gxRasterPrinterType = 'rast';
        gxPostscriptPrinterType = 'post';
        gxVectorPrinterType = 'vect';

{ All pre-defined printing collection items have this ID }
        gxPrintingTagID = -28672;

{    ----------------------------------------------------------------------}
{}
{        Resource types and IDs used by both extension and driver writers}
{}
{    ---------------------------------------------------------------------- }
{ Resources in a printer driver or extension must be based off of these IDs }
        gxPrintingDriverBaseID = -27648;
        gxPrintingExtensionBaseID = -27136;

{    Override resources tell the system what messages a driver or extension}
{        is overriding.  A driver may have a series of these resources. }
        gxOverrideType = 'over';

{    --------------------------------------------------------------}
{}
{        Message ID definitions by both extension and driver writers}
{}
{    --------------------------------------------------------------- }
{ Identifiers for universal message overrides. }
        gxInitializeMsg = 0;
        gxShutDownMsg = 1;
        gxJobIdleMsg = 2;
        gxJobStatusMsg = 3;
        gxPrintingEventMsg = 4;
        gxJobDefaultFormatDialogMsg = 5;
        gxFormatDialogMsg = 6;
        gxJobPrintDialogMsg = 7;
        gxFilterPanelEventMsg = 8;
        gxHandlePanelEventMsg = 9;
        gxParsePageRangeMsg = 10;
        gxDefaultJobMsg = 11;
        gxDefaultFormatMsg = 12;
        gxDefaultPaperTypeMsg = 13;
        gxDefaultPrinterMsg = 14;
        gxCreateSpoolFileMsg = 15;
        gxSpoolPageMsg = 16;
        gxSpoolDataMsg = 17;
        gxSpoolResourceMsg = 18;
        gxCompleteSpoolFileMsg = 19;
        gxCountPagesMsg = 20;
        gxDespoolPageMsg = 21;
        gxDespoolDataMsg = 22;
        gxDespoolResourceMsg = 23;
        gxCloseSpoolFileMsg = 24;
        gxStartJobMsg = 25;
        gxFinishJobMsg = 26;
        gxStartPageMsg = 27;
        gxFinishPageMsg = 28;
        gxPrintPageMsg = 29;
        gxSetupImageDataMsg = 30;
        gxImageJobMsg = 31;
        gxImageDocumentMsg = 32;
        gxImagePageMsg = 33;
        gxRenderPageMsg = 34;
        gxCreateImageFileMsg = 35;
        gxOpenConnectionMsg = 36;
        gxCloseConnectionMsg = 37;
        gxStartSendPageMsg = 38;
        gxFinishSendPageMsg = 39;
        gxWriteDataMsg = 40;
        gxBufferDataMsg = 41;
        gxDumpBufferMsg = 42;
        gxFreeBufferMsg = 43;
        gxCheckStatusMsg = 44;
        gxGetDeviceStatusMsg = 45;
        gxFetchTaggedDataMsg = 46;
        gxGetDTPMenuListMsg = 47;
        gxDTPMenuSelectMsg = 48;
        gxHandleAlertFilterMsg = 49;
        gxJobFormatModeQueryMsg = 50;
        gxWriteStatusToDTPWindowMsg = 51;
        gxInitializeStatusAlertMsg = 52;
        gxHandleAlertStatusMsg = 53;
        gxHandleAlertEventMsg = 54;
        gxCleanupStartJobMsg = 55;
        gxCleanupStartPageMsg = 56;
        gxCleanupOpenConnectionMsg = 57;
        gxCleanupStartSendPageMsg = 58;
        gxDefaultDesktopPrinterMsg = 59;
        gxCaptureOutputDeviceMsg = 60;
        gxOpenConnectionRetryMsg = 61;
        gxExamineSpoolFileMsg = 62;
        gxFinishSendPlaneMsg = 63;
        gxDoesPaperFitMsg = 64;
        gxChooserMessageMsg = 65;
        gxFindPrinterProfileMsg = 66;
        gxFindFormatProfileMsg = 67;
        gxSetPrinterProfileMsg = 68;
        gxSetFormatProfileMsg = 69;
        gxHandleAltDestinationMsg = 70;
        gxSetupPageImageDataMsg = 71;

{ Identifiers for Quickdraw message overrides. }
        gxPrOpenDocMsg = 0;
        gxPrCloseDocMsg = 1;
        gxPrOpenPageMsg = 2;
        gxPrClosePageMsg = 3;
        gxPrintDefaultMsg = 4;
        gxPrStlDialogMsg = 5;
        gxPrJobDialogMsg = 6;
        gxPrStlInitMsg = 7;
        gxPrJobInitMsg = 8;
        gxPrDlgMainMsg = 9;
        gxPrValidateMsg = 10;
        gxPrJobMergeMsg = 11;
        gxPrGeneralMsg = 12;
        gxConvertPrintRecordToMsg = 13;
        gxConvertPrintRecordFromMsg = 14;
        gxPrintRecordToJobMsg = 15;

{ Identifiers for raster imaging message overrides. }
        gxRasterDataInMsg = 0;
        gxRasterLineFeedMsg = 1;
        gxRasterPackageBitmapMsg = 2;

{ Identifiers for PostScript imaging message overrides. }
        gxPostscriptQueryPrinterMsg = 0;
        gxPostscriptInitializePrinterMsg = 1;
        gxPostscriptResetPrinterMsg = 2;
        gxPostscriptExitServerMsg = 3;
        gxPostscriptGetStatusTextMsg = 4;
        gxPostscriptGetPrinterTextMsg = 5;
        gxPostscriptScanStatusTextMsg = 6;
        gxPostscriptScanPrinterTextMsg = 7;
        gxPostscriptGetDocumentProcSetListMsg = 8;
        gxPostscriptDownloadProcSetListMsg = 9;
        gxPostscriptGetPrinterGlyphsInformationMsg = 10;
        gxPostscriptStreamFontMsg = 11;
        gxPostscriptDoDocumentHeaderMsg = 12;
        gxPostscriptDoDocumentSetUpMsg = 13;
        gxPostscriptDoDocumentTrailerMsg = 14;
        gxPostscriptDoPageSetUpMsg = 15;
        gxPostscriptSelectPaperTypeMsg = 16;
        gxPostscriptDoPageTrailerMsg = 17;
        gxPostscriptEjectPageMsg = 18;
        gxPostscriptProcessShapeMsg = 19;
        gxPostScriptEjectPendingPageMsg = 20;

{ Identifiers for Vector imaging message overrides. }
        gxVectorPackageDataMsg = 0;
        gxVectorLoadPensMsg = 1;
        gxVectorVectorizeShapeMsg = 2;

{ Dialog related resource types }
        gxPrintingAlertType = 'plrt';
        gxStatusType = 'stat';
        gxExtendedDITLType = 'xdtl';
        gxPrintPanelType = 'ppnl';
        gxCollectionType = 'cltn';

{ Communication resource types }
{}
{    The looker resource is used by the Chooser PACK to determine what kind}
{    of communications this driver supports. (In order to generate/handle the }
{    pop-up menu for "Connect via:".}
{    }
{    The looker resource is also used by PrinterShare to determine the AppleTalk NBP Type}
{    for servers created for this driver.}
{}
        gxLookerType = 'look';
        gxLookerID = -4096;

{ The communications method and private data used to connect to the printer }
        gxDeviceCommunicationsType = 'comm';

{    -------------------------------------------------}
{}
{    Resource types and IDs used by extension writers}
{}
{    ------------------------------------------------- }
        gxExtensionUniversalOverrideID = gxPrintingExtensionBaseID;

        gxExtensionImagingOverrideSelectorID = gxPrintingExtensionBaseID;

        gxExtensionScopeType = 'scop';
        gxDriverScopeID = gxPrintingExtensionBaseID;
        gxPrinterScopeID = -27135;
        gxPrinterExceptionScopeID = -27134;

        gxExtensionLoadType = 'load';
        gxExtensionLoadID = gxPrintingExtensionBaseID;

        gxExtensionLoadFirst = $00000100;
        gxExtensionLoadAnywhere = $7FFFFFFF;
        gxExtensionLoadLast = $FFFFFF00;

        gxExtensionOptimizationType = 'eopt';
        gxExtensionOptimizationID = gxPrintingExtensionBaseID;

{    -----------------------------------------------}
{}
{    Resource types and IDs used by driver writers}
{}
{    ----------------------------------------------- }
        gxDriverUniversalOverrideID = gxPrintingDriverBaseID;
        gxDriverImagingOverrideID = -27647;
        gxDriverCompatibilityOverrideID = -27646;

        gxDriverFileFormatType = 'pfil';
        gxDriverFileFormatID = gxPrintingDriverBaseID;

        gxDestinationAdditionType = 'dsta';
        gxDestinationAdditionID = gxPrintingDriverBaseID;

{ IMAGING RESOURCES }
{    The imaging system resource specifies which imaging system a printer}
{        driver wishes to use. }
        gxImagingSystemSelectorType = 'isys';
        gxImagingSystemSelectorID = gxPrintingDriverBaseID;

{ 'exft' resource ID -- exclude font list }
        kExcludeFontListType = 'exft';
        kExcludeFontListID = gxPrintingDriverBaseID;

{ Resource for type for color matching }
        gxColorMatchingDataType = 'prof';
        gxColorMatchingDataID = gxPrintingDriverBaseID;

{ Resource type and id for the tray count }
        gxTrayCountDataType = 'tray';
        gxTrayCountDataID = gxPrintingDriverBaseID;

{ Resource type for the tray names }
        gxTrayNameDataType = 'tryn';

{ Resource type for manual feed preferences, stored in DTP. }
        gxManualFeedAlertPrefsType = 'mfpr';
        gxManualFeedAlertPrefsID = gxPrintingDriverBaseID;

{ Resource type for desktop printer output characteristics, stored in DTP. }
        gxDriverOutputType = 'outp';
        gxDriverOutputTypeID = 1;

{ IO Resources }
{ Resource type and ID for default IO and buffering resources }
        gxUniversalIOPrefsType = 'iobm';
        gxUniversalIOPrefsID = gxPrintingDriverBaseID;

{    Resource types and IDs for default implementation of CaptureOutputDevice.}
{        The default implementation of CaptureOutputDevice only handles PAP devices }
        gxCaptureType = 'cpts';
        gxCaptureStringID = gxPrintingDriverBaseID;
        gxReleaseStringID = -27647;
        gxUncapturedAppleTalkType = -27646;
        gxCapturedAppleTalkType = -27645;

{ Resource type and ID for custom halftone matrix }
        gxCustomMatrixType = 'dmat';
        gxCustomMatrixID = gxPrintingDriverBaseID;

{ Resource type and ID for raster driver rendering preferences }
        gxRasterPrefsType = 'rdip';
        gxRasterPrefsID = gxPrintingDriverBaseID;

{ Resource type for specifiying a colorset }
        gxColorSetResType = 'crst';

{ Resource type and ID for raster driver packaging preferences }
        gxRasterPackType = 'rpck';
        gxRasterPackID = gxPrintingDriverBaseID;

{ Resource type and ID for raster driver packaging options }
        gxRasterNumNone = 0;                            { Number isn't output at all }
        gxRasterNumDirect = 1;                            { Lowest minWidth bytes as data }
        gxRasterNumToASCII = 2;                            { minWidth ASCII characters }

        gxRasterPackOptionsType = 'ropt';
        gxRasterPackOptionsID = gxPrintingDriverBaseID;

{ Resource type for the PostScript imaging system procedure set control resource }
        gxPostscriptProcSetControlType = 'prec';

{ Resource type for the PostScript imaging system printer font resource }
        gxPostscriptPrinterFontType = 'pfnt';

{ Resource type and id for the PostScript imaging system imaging preferences }
        gxPostscriptPrefsType = 'pdip';
        gxPostscriptPrefsID = gxPrintingDriverBaseID;

{ Resource type and id for the PostScript imaging system default scanning code }
        gxPostscriptScanningType = 'scan';
        gxPostscriptScanningID = gxPrintingDriverBaseID;

{ Old Application Support Resources }
        gxCustType = 'cust';
        gxCustID = -8192;

        gxReslType = 'resl';
        gxReslID = -8192;

        gxDiscreteResolution = 0;

        gxStlDialogResID = -8192;

        gxJobDialogResID = -8191;

        gxScaleTableType = 'stab';
        gxDITLControlType = 'dctl';

{    The default implementation of gxPrintDefault loads and}
{    PrValidates a print record stored in the following driver resource. }
        gxPrintRecordType = 'PREC';
        gxDefaultPrintRecordID = 0;

{}
{    -----------------------------------------------}
{}
{    Resource types and IDs used in papertype files}
{}
{    -----------------------------------------------}
{}
{ Resource type and ID for driver papertypes placed in individual files }
        gxSignatureType = 'sig ';
        gxPapertypeSignatureID = 0;

{ Papertype creator types }
        gxDrvrPaperType = 'drpt';
        gxSysPaperType = 'sypt';                        { System paper type creator }
        gxUserPaperType = 'uspt';                        { User paper type creator }
{ Driver creator types == driver file's creator value }
        gxPaperTypeType = 'ptyp';

{********************************************************************}
{                    Start of old "GXPrintingMessages.h/a/p" interface file.}
{            *********************************************************************}
{ ------------------------------------------------------------------------------}
{}
{                                    Constants and Types}
{}
{-------------------------------------------------------------------------------- }
{}
{}
{    ABSTRACT DATA TYPES}
{}
{}

    type
        gxSpoolFile = Ptr;

        gxPanelEvent = LONGINT;

{ Dialog panel event equates }

    const
        gxPanelNoEvt = 0;
        gxPanelOpenEvt = 1;                            { Initialize and draw }
        gxPanelCloseEvt = 2;                            { Your panel is going away (panel switch, confirm or cancel) }
        gxPanelHitEvt = 3;                            { There's a hit in your panel }
        gxPanelActivateEvt = 4;                            { The dialog window has just been activated }
        gxPanelDeactivateEvt = 5;                            { The dialog window is about to be deactivated }
        gxPanelIconFocusEvt = 6;                            { The focus changes from the panel to the icon list }
        gxPanelPanelFocusEvt = 7;                            { The focus changes from the icon list to the panel }
        gxPanelFilterEvt = 8;                            { Every event is filtered }
        gxPanelCancelEvt = 9;                            { The user has cancelled the dialog }
        gxPanelConfirmEvt = 10;                            { The user has confirmed the dialog }
        gxPanelDialogEvt = 11;                            { Event to be handle by dialoghandler }
        gxPanelOtherEvt = 12;                            { osEvts, etc. }
        gxPanelUserWillConfirmEvt = 13;                            { User has selected confirm, time to parse panel interdependencies }

{ Constants for panel responses to dialog handler calls }

    type
        gxPanelResult = LONGINT;


    const
        gxPanelNoResult = 0;
        gxPanelCancelConfirmation = 1;                            { Only valid from panelUserWillConfirmEvt - used to keep the dialog from going away }

{ Panel event info record for FilterPanelEvent and HandlePanelEvent messages }

    type
        gxPanelInfoRecord = record
                panelEvt: gxPanelEvent;                            { Why we were called }
                panelResId: INTEGER;                                { 'ppnl' resource id of current panel }
                pDlg: DialogPtr;                                { Pointer to dialog }
                theEvent: ^EventRecord;                            { Pointer to event }
                itemHit: INTEGER;                                { Actual item number as Dialog Mgr thinks }
                itemCount: INTEGER;                                { Number of items before your items }
                evtAction: INTEGER;                                { Once this event is processed, the action that will result }
        { (evtAction is only meaningful during filtering) }
                errorStringId: INTEGER;                                { STR id of string to put in error alert (0 means no string) }
                theFormat: gxFormat;                                { The current format (only meaningful in a format dialog) }
                refCon: Ptr;                                    { refCon passed in PanelSetupRecord }
            end;

{ Constants for the evtAction field in PanelInfoRecord }

    const
        gxOtherAction = 0;                            { Current item will not change }
        gxClosePanelAction = 1;                            { Panel will be closed }
        gxCancelDialogAction = 2;                            { Dialog will be cancelled }
        gxConfirmDialogAction = 3;                            { Dialog will be confirmed }

{ Constants for the panelKind field in gxPanelSetupRecord }

    type
        gxPrintingPanelKind = LONGINT;

{ The gxPanelSetupInfo structure is passed to GXSetupDialogPanel }
        gxPanelSetupRecord = record
                panelKind: gxPrintingPanelKind;
                panelResId: INTEGER;
                resourceRefNum: INTEGER;
                refCon: Ptr;
            end;


    const
        gxApplicationPanel = 0;
        gxExtensionPanel = 1;
        gxDriverPanel = 2;

{ Constants returned by gxParsePageRange message }

    type
        gxParsePageRangeResult = LONGINT;


    const
        gxRangeNotParsed = 0;                            { Default initial value }
        gxRangeParsed = 1;                            { Range has been parsed }
        gxRangeBadFromValue = 2;                            { From value is bad }
        gxRangeBadToValue = 3;                            { To value is bad }

{}
{}
{    STATUS-RELATED CONSTANTS AND TYPES}
{}
{}
{ Structure for status messages }

    type
        gxStatusRecord = record
                statusType: INTEGER;                                { One of the ids listed above (nonFatalError, etc. ) }
                statusId: INTEGER;                                { Specific status (out of paper, etc.) }
                statusAlertId: INTEGER;                                {    Printing alert id (if any) for status }
                statusOwner: gxOwnerSignature;                        { Creator type of status owner }
                statResId: INTEGER;                                { ID for 'stat' resource }
                statResIndex: INTEGER;                                { Index into 'stat' resource for this status }
                dialogResult: INTEGER;                                { ID of button string selected on dismissal of printing alert }
                bufferLen: INTEGER;                                { Number of bytes in status buffer - total record size must be <= 512 }
                statusBuffer: array[0..0] of CHAR;                    { User response from alert }
            end;

{ Constants for statusType field of gxStatusRecord }

    const
        gxNonFatalError = 1;                            { An error occurred, but the job can continue }
        gxFatalError = 2;                            { A fatal error occurred-- halt job }
        gxPrinterReady = 3;                            { Tells QDGX to leave alert mode }
        gxUserAttention = 4;                            { Signals initiation of a modal alert }
        gxUserAlert = 5;                            { Signals initiation of a moveable modal alert }
        gxPageTransmission = 6;                            { Signals page sent to printer, increments page count in strings to user }
        gxOpenConnectionStatus = 7;                            { Signals QDGX to begin animation on printer icon }
        gxInformationalStatus = 8;                            { Default status type, no side effects }
        gxSpoolingPageStatus = 9;                            { Signals page spooled, increments page count in spooling dialog }
        gxEndStatus = 10;                            { Signals end of spooling }
        gxPercentageStatus = 11;                            { Signals QDGX as to the amount of the job which is currently complete }

{ Structure for gxWriteStatusToDTPWindow message }

    type
        gxDisplayRecord = record
                useText: BOOLEAN;                                { Use text as opposed to a picture }
                padByte: CHAR;
                hPicture: Handle;                                    { if !useText, the picture handle }
                theText: Str255;                                    { if useText, the text }
            end;

{-----------------------------------------------}
{ paper mapping-related constants and types...  }
{-----------------------------------------------}
        gxTrayMapping = LONGINT;


    const
        gxDefaultTrayMapping = 0;
        gxConfiguredTrayMapping = 1;

{ ------------------------------------------------------------------------------}
{}
{                API Functions callable only from within message overrides}
{}
{-------------------------------------------------------------------------------- }
{$IFC NOT GENERATINGPOWERPC }
{$ENDC}

{FUNCTION GXGetJob: gxJob; C;}
{FUNCTION GXGetMessageHandlerResFile: INTEGER; C;}
{FUNCTION GXSpoolingAborted: BOOLEAN; C;}
{FUNCTION GXJobIdle: OSErr; C;}
{FUNCTION GXReportStatus(statusID: LONGINT; statusIndex: LONGINT): OSErr; C;}
{FUNCTION GXAlertTheUser(VAR statusRec: gxStatusRecord): OSErr; C;}
{FUNCTION GXSetupDialogPanel(VAR panelRec: gxPanelSetupRecord): OSErr; C;}
{FUNCTION GXCountTrays(VAR numTrays: gxTrayIndex): OSErr; C;}
{FUNCTION GXGetTrayName(trayNumber: gxTrayIndex; VAR trayName: Str31): OSErr; C;}
{FUNCTION GXSetTrayPaperType(whichTray: gxTrayIndex; aPapertype: gxPaperType): OSErr; C;}
{FUNCTION GXGetTrayPaperType(whichTray: gxTrayIndex; aPapertype: gxPaperType): OSErr; C;}
{FUNCTION GXGetTrayMapping(VAR trayMapping: gxTrayMapping): OSErr; C;}
{PROCEDURE GXCleanupStartJob; C;}
{PROCEDURE GXCleanupStartPage; C;}
{PROCEDURE GXCleanupOpenConnection; C;}
{PROCEDURE GXCleanupStartSendPage; C;}
{ ------------------------------------------------------------------------------}
{}
{                    Constants and types for Universal Printing Messages}
{}
{-------------------------------------------------------------------------------- }
{ Options for gxCreateSpoolFile message }

    const
        gxNoCreateOptions = $00000000;                    { Just create the file }
        gxInhibitAlias = $00000001;                    { Do not create an alias in the PMD folder }
        gxInhibitUniqueName = $00000002;                    { Do not append to the filename to make it unique }
        gxResolveBitmapAlias = $00000004;                    { Resolve bitmap aliases and duplicate data in file }

{ Options for gxCloseSpoolFile message }
        gxNoCloseOptions = $00000000;                    { Just close the file }
        gxDeleteOnClose = $00000001;                    { Delete the file rather than closing it }
        gxUpdateJobData = $00000002;                    { Write current job information into file prior to closing }
        gxMakeRemoteFile = $00000004;                    { Mark job as a remote file }

{ Options for gxCreateImageFile message }
        gxNoImageFile = $00000000;                    { Don't create image file }
        gxMakeImageFile = $00000001;                    { Create an image file }
        gxEachPlane = $00000002;                    { Only save up planes before rewinding }
        gxEachPage = $00000004;                    { Save up entire pages before rewinding }
        gxEntireFile = $6;        { Save up the entire file before rewinding }

{ Options for gxBufferData message }
        gxNoBufferOptions = $00000000;
        gxMakeBufferHex = $00000001;
        gxDontSplitBuffer = $00000002;

{ Structure for gxDumpBuffer and gxFreeBuffer messages }

    type
        gxPrintingBuffer = record
                size: LONGINT;                                { Size of buffer in bytes }
                userData: LONGINT;                                { Client assigned id for the buffer }
                data: array[0..0] of CHAR;                    { Array of size bytes }
            end;

{ Structure for gxRenderPage message }
        gxPageInfoRecord = record
                docPageNum: LONGINT;                                { Number of page being printed }
                copyNum: LONGINT;                                { Copy number being printed }
                formatChanged: BOOLEAN;                                { True if format changed from last page }
                pageChanged: BOOLEAN;                                { True if page contents changed from last page }
                internalUse: LONGINT;                                { Private }
            end;

{ ------------------------------------------------------------------------------}
{}
{                                Universal Printing Messages}
{}
{-------------------------------------------------------------------------------- }
        GXJobIdleProcPtr = ProcPtr;  { FUNCTION GXJobIdle: OSErr; }
        GXJobIdleUPP = UniversalProcPtr;

    const
        uppGXJobIdleProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXJobIdleProc (userRoutine: GXJobIdleProcPtr): GXJobIdleUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXJobIdleProc (userRoutine: GXJobIdleUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXJobIdleProc = GXJobIdleUPP;


{FUNCTION Send_GXJobIdle: OSErr; C;}
{FUNCTION Forward_GXJobIdle: OSErr; C;}
    type
        GXJobStatusProcPtr = ProcPtr;  { FUNCTION GXJobStatus(VAR pStatus: gxStatusRecord): OSErr; }
        GXJobStatusUPP = UniversalProcPtr;

    const
        uppGXJobStatusProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXJobStatusProc (userRoutine: GXJobStatusProcPtr): GXJobStatusUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXJobStatusProc (var pStatus: gxStatusRecord; userRoutine: GXJobStatusUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXJobStatusProc = GXJobStatusUPP;


{FUNCTION Send_GXJobStatus(VAR pStatus: gxStatusRecord): OSErr; C;}
{FUNCTION Forward_GXJobStatus(VAR pStatus: gxStatusRecord): OSErr; C;}
    type
        GXPrintingEventProcPtr = ProcPtr;  { FUNCTION GXPrintingEvent(VAR evtRecord: EventRecord; filterEvent: BOOLEAN): OSErr; }
        GXPrintingEventUPP = UniversalProcPtr;

    const
        uppGXPrintingEventProcInfo = $000001E1; { FUNCTION (4 byte param, 1 byte param): 2 byte result; }

    function NewGXPrintingEventProc (userRoutine: GXPrintingEventProcPtr): GXPrintingEventUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXPrintingEventProc (var evtRecord: EventRecord; filterEvent: BOOLEAN; userRoutine: GXPrintingEventUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXPrintingEventProc = GXPrintingEventUPP;


{FUNCTION Send_GXPrintingEvent(VAR evtRecord: EventRecord; filterEvent: BOOLEAN): OSErr; C;}
{FUNCTION Forward_GXPrintingEvent(VAR evtRecord: EventRecord; filterEvent: BOOLEAN): OSErr; C;}
    type
        GXJobDefaultFormatDialogProcPtr = ProcPtr;  { FUNCTION GXJobDefaultFormatDialog(VAR dlgResult: gxDialogResult): OSErr; }
        GXJobDefaultFormatDialogUPP = UniversalProcPtr;

    const
        uppGXJobDefaultFormatDialogProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXJobDefaultFormatDialogProc (userRoutine: GXJobDefaultFormatDialogProcPtr): GXJobDefaultFormatDialogUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXJobDefaultFormatDialogProc (var dlgResult: gxDialogResult; userRoutine: GXJobDefaultFormatDialogUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXJobDefaultFormatDialogProc = GXJobDefaultFormatDialogUPP;


{FUNCTION Send_GXJobDefaultFormatDialog(VAR dlgResult: gxDialogResult): OSErr; C;}
{FUNCTION Forward_GXJobDefaultFormatDialog(VAR dlgResult: gxDialogResult): OSErr; C;}
    type
        GXFormatDialogProcPtr = ProcPtr;  { FUNCTION GXFormatDialog(theFormat: gxFormat; title: StringPtr; VAR dlgResult: gxDialogResult): OSErr; }
        GXFormatDialogUPP = UniversalProcPtr;

    const
        uppGXFormatDialogProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXFormatDialogProc (userRoutine: GXFormatDialogProcPtr): GXFormatDialogUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFormatDialogProc (theFormat: gxFormat; title: StringPtr; var dlgResult: gxDialogResult; userRoutine: GXFormatDialogUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFormatDialogProc = GXFormatDialogUPP;


{FUNCTION Send_GXFormatDialog(theFormat: gxFormat; title: StringPtr; VAR dlgResult: gxDialogResult): OSErr; C;}
{FUNCTION Forward_GXFormatDialog(theFormat: gxFormat; title: StringPtr; VAR dlgResult: gxDialogResult): OSErr; C;}
    type
        GXJobPrintDialogProcPtr = ProcPtr;  { FUNCTION GXJobPrintDialog(VAR dlgResult: gxDialogResult): OSErr; }
        GXJobPrintDialogUPP = UniversalProcPtr;

    const
        uppGXJobPrintDialogProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXJobPrintDialogProc (userRoutine: GXJobPrintDialogProcPtr): GXJobPrintDialogUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXJobPrintDialogProc (var dlgResult: gxDialogResult; userRoutine: GXJobPrintDialogUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXJobPrintDialogProc = GXJobPrintDialogUPP;


{FUNCTION Send_GXJobPrintDialog(VAR dlgResult: gxDialogResult): OSErr; C;}
{FUNCTION Forward_GXJobPrintDialog(VAR dlgResult: gxDialogResult): OSErr; C;}
    type
        GXFilterPanelEventProcPtr = ProcPtr;  { FUNCTION GXFilterPanelEvent(VAR pHitInfo: gxPanelInfoRecord; VAR returnImmed: BOOLEAN): OSErr; }
        GXFilterPanelEventUPP = UniversalProcPtr;

    const
        uppGXFilterPanelEventProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXFilterPanelEventProc (userRoutine: GXFilterPanelEventProcPtr): GXFilterPanelEventUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFilterPanelEventProc (var pHitInfo: gxPanelInfoRecord; var returnImmed: BOOLEAN; userRoutine: GXFilterPanelEventUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFilterPanelEventProc = GXFilterPanelEventUPP;


{FUNCTION Send_GXFilterPanelEvent(VAR pHitInfo: gxPanelInfoRecord; VAR returnImmed: BOOLEAN): OSErr; C;}
    type
        GXHandlePanelEventProcPtr = ProcPtr;  { FUNCTION GXHandlePanelEvent(VAR pHitInfo: gxPanelInfoRecord; VAR panelResponse: gxPanelResult): OSErr; }
        GXHandlePanelEventUPP = UniversalProcPtr;

    const
        uppGXHandlePanelEventProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXHandlePanelEventProc (userRoutine: GXHandlePanelEventProcPtr): GXHandlePanelEventUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXHandlePanelEventProc (var pHitInfo: gxPanelInfoRecord; var panelResponse: gxPanelResult; userRoutine: GXHandlePanelEventUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXHandlePanelEventProc = GXHandlePanelEventUPP;


{FUNCTION Send_GXHandlePanelEvent(VAR pHitInfo: gxPanelInfoRecord; VAR panelResponse: gxPanelResult): OSErr; C;}
    type
        GXParsePageRangeProcPtr = ProcPtr;  { FUNCTION GXParsePageRange(fromString: StringPtr; toString: StringPtr; VAR result: gxParsePageRangeResult): OSErr; }
        GXParsePageRangeUPP = UniversalProcPtr;

    const
        uppGXParsePageRangeProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXParsePageRangeProc (userRoutine: GXParsePageRangeProcPtr): GXParsePageRangeUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXParsePageRangeProc (fromString: StringPtr; toString: StringPtr; var result: gxParsePageRangeResult; userRoutine: GXParsePageRangeUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXParsePageRangeProc = GXParsePageRangeUPP;


{FUNCTION Send_GXParsePageRange(fromString: StringPtr; toString: StringPtr; VAR result: gxParsePageRangeResult): OSErr; C;}
{FUNCTION Forward_GXParsePageRange(fromString: StringPtr; toString: StringPtr; VAR result: gxParsePageRangeResult): OSErr; C;}
    type
        GXDefaultJobProcPtr = ProcPtr;  { FUNCTION GXDefaultJob: OSErr; }
        GXDefaultJobUPP = UniversalProcPtr;

    const
        uppGXDefaultJobProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXDefaultJobProc (userRoutine: GXDefaultJobProcPtr): GXDefaultJobUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDefaultJobProc (userRoutine: GXDefaultJobUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDefaultJobProc = GXDefaultJobUPP;


{FUNCTION Send_GXDefaultJob: OSErr; C;}
{FUNCTION Forward_GXDefaultJob: OSErr; C;}
    type
        GXDefaultFormatProcPtr = ProcPtr;  { FUNCTION GXDefaultFormat(theFormat: gxFormat): OSErr; }
        GXDefaultFormatUPP = UniversalProcPtr;

    const
        uppGXDefaultFormatProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXDefaultFormatProc (userRoutine: GXDefaultFormatProcPtr): GXDefaultFormatUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDefaultFormatProc (theFormat: gxFormat; userRoutine: GXDefaultFormatUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDefaultFormatProc = GXDefaultFormatUPP;


{FUNCTION Send_GXDefaultFormat(theFormat: gxFormat): OSErr; C;}
{FUNCTION Forward_GXDefaultFormat(theFormat: gxFormat): OSErr; C;}
    type
        GXDefaultPaperTypeProcPtr = ProcPtr;  { FUNCTION GXDefaultPaperType(thePaperType: gxPaperType): OSErr; }
        GXDefaultPaperTypeUPP = UniversalProcPtr;

    const
        uppGXDefaultPaperTypeProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXDefaultPaperTypeProc (userRoutine: GXDefaultPaperTypeProcPtr): GXDefaultPaperTypeUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDefaultPaperTypeProc (thePaperType: gxPaperType; userRoutine: GXDefaultPaperTypeUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDefaultPaperTypeProc = GXDefaultPaperTypeUPP;


{FUNCTION Send_GXDefaultPaperType(thePaperType: gxPaperType): OSErr; C;}
{FUNCTION Forward_GXDefaultPaperType(thePaperType: gxPaperType): OSErr; C;}
    type
        GXDefaultPrinterProcPtr = ProcPtr;  { FUNCTION GXDefaultPrinter(thePrinter: gxPrinter): OSErr; }
        GXDefaultPrinterUPP = UniversalProcPtr;

    const
        uppGXDefaultPrinterProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXDefaultPrinterProc (userRoutine: GXDefaultPrinterProcPtr): GXDefaultPrinterUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDefaultPrinterProc (thePrinter: gxPrinter; userRoutine: GXDefaultPrinterUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDefaultPrinterProc = GXDefaultPrinterUPP;


{FUNCTION Send_GXDefaultPrinter(thePrinter: gxPrinter): OSErr; C;}
{FUNCTION Forward_GXDefaultPrinter(thePrinter: gxPrinter): OSErr; C;}
    type
        GXCreateSpoolFileProcPtr = ProcPtr;  { FUNCTION GXCreateSpoolFile(pFileSpec: FSSpecPtr; createOptions: LONGINT; VAR theSpoolFile: gxSpoolFile): OSErr; }
        GXCreateSpoolFileUPP = UniversalProcPtr;

    const
        uppGXCreateSpoolFileProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXCreateSpoolFileProc (userRoutine: GXCreateSpoolFileProcPtr): GXCreateSpoolFileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCreateSpoolFileProc (pFileSpec: FSSpecPtr; createOptions: LONGINT; var theSpoolFile: gxSpoolFile; userRoutine: GXCreateSpoolFileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCreateSpoolFileProc = GXCreateSpoolFileUPP;


{FUNCTION Send_GXCreateSpoolFile(pFileSpec: FSSpecPtr; createOptions: LONGINT; VAR theSpoolFile: gxSpoolFile): OSErr; C;}
{FUNCTION Forward_GXCreateSpoolFile(pFileSpec: FSSpecPtr; createOptions: LONGINT; VAR theSpoolFile: gxSpoolFile): OSErr; C;}
    type
        GXSpoolPageProcPtr = ProcPtr;  { FUNCTION GXSpoolPage(theSpoolFile: gxSpoolFile; theFormat: gxFormat; thePage: gxShape): OSErr; }
        GXSpoolPageUPP = UniversalProcPtr;

    const
        uppGXSpoolPageProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXSpoolPageProc (userRoutine: GXSpoolPageProcPtr): GXSpoolPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXSpoolPageProc (theSpoolFile: gxSpoolFile; theFormat: gxFormat; thePage: gxShape; userRoutine: GXSpoolPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXSpoolPageProc = GXSpoolPageUPP;


{FUNCTION Send_GXSpoolPage(theSpoolFile: gxSpoolFile; theFormat: gxFormat; thePage: gxShape): OSErr; C;}
{FUNCTION Forward_GXSpoolPage(theSpoolFile: gxSpoolFile; theFormat: gxFormat; thePage: gxShape): OSErr; C;}
    type
        GXSpoolDataProcPtr = ProcPtr;  { FUNCTION GXSpoolData(theSpoolFile: gxSpoolFile; data: Ptr; VAR length: LONGINT): OSErr; }
        GXSpoolDataUPP = UniversalProcPtr;

    const
        uppGXSpoolDataProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXSpoolDataProc (userRoutine: GXSpoolDataProcPtr): GXSpoolDataUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXSpoolDataProc (theSpoolFile: gxSpoolFile; data: Ptr; var length: LONGINT; userRoutine: GXSpoolDataUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXSpoolDataProc = GXSpoolDataUPP;


{FUNCTION Send_GXSpoolData(theSpoolFile: gxSpoolFile; data: Ptr; VAR length: LONGINT): OSErr; C;}
{FUNCTION Forward_GXSpoolData(theSpoolFile: gxSpoolFile; data: Ptr; VAR length: LONGINT): OSErr; C;}
    type
        GXSpoolResourceProcPtr = ProcPtr;  { FUNCTION GXSpoolResource(theSpoolFile: gxSpoolFile; theResource: Handle; theType: ResType; id: LONGINT): OSErr; }
        GXSpoolResourceUPP = UniversalProcPtr;

    const
        uppGXSpoolResourceProcInfo = $00003FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXSpoolResourceProc (userRoutine: GXSpoolResourceProcPtr): GXSpoolResourceUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXSpoolResourceProc (theSpoolFile: gxSpoolFile; theResource: Handle; theType: ResType; id: LONGINT; userRoutine: GXSpoolResourceUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXSpoolResourceProc = GXSpoolResourceUPP;


{FUNCTION Send_GXSpoolResource(theSpoolFile: gxSpoolFile; theResource: Handle; theType: ResType; id: LONGINT): OSErr; C;}
{FUNCTION Forward_GXSpoolResource(theSpoolFile: gxSpoolFile; theResource: Handle; theType: ResType; id: LONGINT): OSErr; C;}
    type
        GXCompleteSpoolFileProcPtr = ProcPtr;  { FUNCTION GXCompleteSpoolFile(theSpoolFile: gxSpoolFile): OSErr; }
        GXCompleteSpoolFileUPP = UniversalProcPtr;

    const
        uppGXCompleteSpoolFileProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXCompleteSpoolFileProc (userRoutine: GXCompleteSpoolFileProcPtr): GXCompleteSpoolFileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCompleteSpoolFileProc (theSpoolFile: gxSpoolFile; userRoutine: GXCompleteSpoolFileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCompleteSpoolFileProc = GXCompleteSpoolFileUPP;


{FUNCTION Send_GXCompleteSpoolFile(theSpoolFile: gxSpoolFile): OSErr; C;}
{FUNCTION Forward_GXCompleteSpoolFile(theSpoolFile: gxSpoolFile): OSErr; C;}
    type
        GXCountPagesProcPtr = ProcPtr;  { FUNCTION GXCountPages(theSpoolFile: gxSpoolFile; VAR numPages: LONGINT): OSErr; }
        GXCountPagesUPP = UniversalProcPtr;

    const
        uppGXCountPagesProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXCountPagesProc (userRoutine: GXCountPagesProcPtr): GXCountPagesUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCountPagesProc (theSpoolFile: gxSpoolFile; var numPages: LONGINT; userRoutine: GXCountPagesUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCountPagesProc = GXCountPagesUPP;


{FUNCTION Send_GXCountPages(theSpoolFile: gxSpoolFile; VAR numPages: LONGINT): OSErr; C;}
{FUNCTION Forward_GXCountPages(theSpoolFile: gxSpoolFile; VAR numPages: LONGINT): OSErr; C;}
    type
        GXDespoolPageProcPtr = ProcPtr;  { FUNCTION GXDespoolPage(theSpoolFile: gxSpoolFile; numPages: LONGINT; theFormat: gxFormat; VAR thePage: gxShape; VAR formatChanged: BOOLEAN): OSErr; }
        GXDespoolPageUPP = UniversalProcPtr;

    const
        uppGXDespoolPageProcInfo = $0000FFE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXDespoolPageProc (userRoutine: GXDespoolPageProcPtr): GXDespoolPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDespoolPageProc (theSpoolFile: gxSpoolFile; numPages: LONGINT; theFormat: gxFormat; var thePage: gxShape; var formatChanged: BOOLEAN; userRoutine: GXDespoolPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDespoolPageProc = GXDespoolPageUPP;


{FUNCTION Send_GXDespoolPage(theSpoolFile: gxSpoolFile; numPages: LONGINT; theFormat: gxFormat; VAR thePage: gxShape; VAR formatChanged: BOOLEAN): OSErr; C;}
{FUNCTION Forward_GXDespoolPage(theSpoolFile: gxSpoolFile; numPages: LONGINT; theFormat: gxFormat; VAR thePage: gxShape; VAR formatChanged: BOOLEAN): OSErr; C;}
    type
        GXDespoolDataProcPtr = ProcPtr;  { FUNCTION GXDespoolData(theSpoolFile: gxSpoolFile; data: Ptr; VAR length: LONGINT): OSErr; }
        GXDespoolDataUPP = UniversalProcPtr;

    const
        uppGXDespoolDataProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXDespoolDataProc (userRoutine: GXDespoolDataProcPtr): GXDespoolDataUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDespoolDataProc (theSpoolFile: gxSpoolFile; data: Ptr; var length: LONGINT; userRoutine: GXDespoolDataUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDespoolDataProc = GXDespoolDataUPP;


{FUNCTION Send_GXDespoolData(theSpoolFile: gxSpoolFile; data: Ptr; VAR length: LONGINT): OSErr; C;}
{FUNCTION Forward_GXDespoolData(theSpoolFile: gxSpoolFile; data: Ptr; VAR length: LONGINT): OSErr; C;}
    type
        GXDespoolResourceProcPtr = ProcPtr;  { FUNCTION GXDespoolResource(theSpoolFile: gxSpoolFile; theType: ResType; id: LONGINT; VAR theResource: Handle): OSErr; }
        GXDespoolResourceUPP = UniversalProcPtr;

    const
        uppGXDespoolResourceProcInfo = $00003FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXDespoolResourceProc (userRoutine: GXDespoolResourceProcPtr): GXDespoolResourceUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDespoolResourceProc (theSpoolFile: gxSpoolFile; theType: ResType; id: LONGINT; var theResource: Handle; userRoutine: GXDespoolResourceUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDespoolResourceProc = GXDespoolResourceUPP;


{FUNCTION Send_GXDespoolResource(theSpoolFile: gxSpoolFile; theType: ResType; id: LONGINT; VAR theResource: Handle): OSErr; C;}
{FUNCTION Forward_GXDespoolResource(theSpoolFile: gxSpoolFile; theType: ResType; id: LONGINT; VAR theResource: Handle): OSErr; C;}
    type
        GXCloseSpoolFileProcPtr = ProcPtr;  { FUNCTION GXCloseSpoolFile(theSpoolFile: gxSpoolFile; closeOptions: LONGINT): OSErr; }
        GXCloseSpoolFileUPP = UniversalProcPtr;

    const
        uppGXCloseSpoolFileProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXCloseSpoolFileProc (userRoutine: GXCloseSpoolFileProcPtr): GXCloseSpoolFileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCloseSpoolFileProc (theSpoolFile: gxSpoolFile; closeOptions: LONGINT; userRoutine: GXCloseSpoolFileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCloseSpoolFileProc = GXCloseSpoolFileUPP;


{FUNCTION Send_GXCloseSpoolFile(theSpoolFile: gxSpoolFile; closeOptions: LONGINT): OSErr; C;}
{FUNCTION Forward_GXCloseSpoolFile(theSpoolFile: gxSpoolFile; closeOptions: LONGINT): OSErr; C;}
    type
        GXStartJobProcPtr = ProcPtr;  { FUNCTION GXStartJob(docName: StringPtr; pageCount: LONGINT): OSErr; }
        GXStartJobUPP = UniversalProcPtr;

    const
        uppGXStartJobProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXStartJobProc (userRoutine: GXStartJobProcPtr): GXStartJobUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXStartJobProc (docName: StringPtr; pageCount: LONGINT; userRoutine: GXStartJobUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXStartJobProc = GXStartJobUPP;


{FUNCTION Send_GXStartJob(docName: StringPtr; pageCount: LONGINT): OSErr; C;}
{FUNCTION Forward_GXStartJob(docName: StringPtr; pageCount: LONGINT): OSErr; C;}
    type
        GXFinishJobProcPtr = ProcPtr;  { FUNCTION GXFinishJob: OSErr; }
        GXFinishJobUPP = UniversalProcPtr;

    const
        uppGXFinishJobProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXFinishJobProc (userRoutine: GXFinishJobProcPtr): GXFinishJobUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFinishJobProc (userRoutine: GXFinishJobUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFinishJobProc = GXFinishJobUPP;


{FUNCTION Send_GXFinishJob: OSErr; C;}
{FUNCTION Forward_GXFinishJob: OSErr; C;}
    type
        GXStartPageProcPtr = ProcPtr;  { FUNCTION GXStartPage(theFormat: gxFormat; numViewPorts: LONGINT; VAR viewPortList: gxViewPort): OSErr; }
        GXStartPageUPP = UniversalProcPtr;

    const
        uppGXStartPageProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXStartPageProc (userRoutine: GXStartPageProcPtr): GXStartPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXStartPageProc (theFormat: gxFormat; numViewPorts: LONGINT; var viewPortList: gxViewPort; userRoutine: GXStartPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXStartPageProc = GXStartPageUPP;


{FUNCTION Send_GXStartPage(theFormat: gxFormat; numViewPorts: LONGINT; VAR viewPortList: gxViewPort): OSErr; C;}
{FUNCTION Forward_GXStartPage(theFormat: gxFormat; numViewPorts: LONGINT; VAR viewPortList: gxViewPort): OSErr; C;}
    type
        GXFinishPageProcPtr = ProcPtr;  { FUNCTION GXFinishPage: OSErr; }
        GXFinishPageUPP = UniversalProcPtr;

    const
        uppGXFinishPageProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXFinishPageProc (userRoutine: GXFinishPageProcPtr): GXFinishPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFinishPageProc (userRoutine: GXFinishPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFinishPageProc = GXFinishPageUPP;


{FUNCTION Send_GXFinishPage: OSErr; C;}
{FUNCTION Forward_GXFinishPage: OSErr; C;}
    type
        GXPrintPageProcPtr = ProcPtr;  { FUNCTION GXPrintPage(theFormat: gxFormat; thePage: gxShape): OSErr; }
        GXPrintPageUPP = UniversalProcPtr;

    const
        uppGXPrintPageProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXPrintPageProc (userRoutine: GXPrintPageProcPtr): GXPrintPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXPrintPageProc (theFormat: gxFormat; thePage: gxShape; userRoutine: GXPrintPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXPrintPageProc = GXPrintPageUPP;


{FUNCTION Send_GXPrintPage(theFormat: gxFormat; thePage: gxShape): OSErr; C;}
{FUNCTION Forward_GXPrintPage(theFormat: gxFormat; thePage: gxShape): OSErr; C;}
    type
        GXSetupImageDataProcPtr = ProcPtr;  { FUNCTION GXSetupImageData(imageData: UNIV Ptr): OSErr; }
        GXSetupImageDataUPP = UniversalProcPtr;

    const
        uppGXSetupImageDataProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXSetupImageDataProc (userRoutine: GXSetupImageDataProcPtr): GXSetupImageDataUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXSetupImageDataProc (imageData: univ Ptr; userRoutine: GXSetupImageDataUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXSetupImageDataProc = GXSetupImageDataUPP;


{FUNCTION Send_GXSetupImageData(imageData: UNIV Ptr): OSErr; C;}
{FUNCTION Forward_GXSetupImageData(imageData: UNIV Ptr): OSErr; C;}
    type
        GXImageJobProcPtr = ProcPtr;  { FUNCTION GXImageJob(theSpoolFile: gxSpoolFile; VAR closeOptions: LONGINT): OSErr; }
        GXImageJobUPP = UniversalProcPtr;

    const
        uppGXImageJobProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXImageJobProc (userRoutine: GXImageJobProcPtr): GXImageJobUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXImageJobProc (theSpoolFile: gxSpoolFile; var closeOptions: LONGINT; userRoutine: GXImageJobUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXImageJobProc = GXImageJobUPP;


{FUNCTION Send_GXImageJob(theSpoolFile: gxSpoolFile; VAR closeOptions: LONGINT): OSErr; C;}
{FUNCTION Forward_GXImageJob(theSpoolFile: gxSpoolFile; VAR closeOptions: LONGINT): OSErr; C;}
    type
        GXImageDocumentProcPtr = ProcPtr;  { FUNCTION GXImageDocument(theSpoolFile: gxSpoolFile; imageData: UNIV Ptr): OSErr; }
        GXImageDocumentUPP = UniversalProcPtr;

    const
        uppGXImageDocumentProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXImageDocumentProc (userRoutine: GXImageDocumentProcPtr): GXImageDocumentUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXImageDocumentProc (theSpoolFile: gxSpoolFile; imageData: univ Ptr; userRoutine: GXImageDocumentUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXImageDocumentProc = GXImageDocumentUPP;


{FUNCTION Send_GXImageDocument(theSpoolFile: gxSpoolFile; imageData: UNIV Ptr): OSErr; C;}
{FUNCTION Forward_GXImageDocument(theSpoolFile: gxSpoolFile; imageData: UNIV Ptr): OSErr; C;}
    type
        GXImagePageProcPtr = ProcPtr;  { FUNCTION GXImagePage(theSpoolFile: gxSpoolFile; pageNumber: LONGINT; theFormat: gxFormat; imageData: UNIV Ptr): OSErr; }
        GXImagePageUPP = UniversalProcPtr;

    const
        uppGXImagePageProcInfo = $00003FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXImagePageProc (userRoutine: GXImagePageProcPtr): GXImagePageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXImagePageProc (theSpoolFile: gxSpoolFile; pageNumber: LONGINT; theFormat: gxFormat; imageData: univ Ptr; userRoutine: GXImagePageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXImagePageProc = GXImagePageUPP;


{FUNCTION Send_GXImagePage(theSpoolFile: gxSpoolFile; pageNumber: LONGINT; theFormat: gxFormat; imageData: UNIV Ptr): OSErr; C;}
{FUNCTION Forward_GXImagePage(theSpoolFile: gxSpoolFile; pageNumber: LONGINT; theFormat: gxFormat; imageData: UNIV Ptr): OSErr; C;}
    type
        GXRenderPageProcPtr = ProcPtr;  { FUNCTION GXRenderPage(theFormat: gxFormat; thePage: gxShape; VAR pageInfo: gxPageInfoRecord; imageData: UNIV Ptr): OSErr; }
        GXRenderPageUPP = UniversalProcPtr;

    const
        uppGXRenderPageProcInfo = $00003FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXRenderPageProc (userRoutine: GXRenderPageProcPtr): GXRenderPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXRenderPageProc (theFormat: gxFormat; thePage: gxShape; var pageInfo: gxPageInfoRecord; imageData: univ Ptr; userRoutine: GXRenderPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXRenderPageProc = GXRenderPageUPP;


{FUNCTION Send_GXRenderPage(theFormat: gxFormat; thePage: gxShape; VAR pageInfo: gxPageInfoRecord; imageData: UNIV Ptr): OSErr; C;}
{FUNCTION Forward_GXRenderPage(theFormat: gxFormat; thePage: gxShape; VAR pageInfo: gxPageInfoRecord; imageData: UNIV Ptr): OSErr; C;}
    type
        GXCreateImageFileProcPtr = ProcPtr;  { FUNCTION GXCreateImageFile(pFileSpec: FSSpecPtr; imageFileOptions: LONGINT; VAR theImageFile: LONGINT): OSErr; }
        GXCreateImageFileUPP = UniversalProcPtr;

    const
        uppGXCreateImageFileProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXCreateImageFileProc (userRoutine: GXCreateImageFileProcPtr): GXCreateImageFileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCreateImageFileProc (pFileSpec: FSSpecPtr; imageFileOptions: LONGINT; var theImageFile: LONGINT; userRoutine: GXCreateImageFileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCreateImageFileProc = GXCreateImageFileUPP;


{FUNCTION Send_GXCreateImageFile(pFileSpec: FSSpecPtr; imageFileOptions: LONGINT; VAR theImageFile: LONGINT): OSErr; C;}
{FUNCTION Forward_GXCreateImageFile(pFileSpec: FSSpecPtr; imageFileOptions: LONGINT; VAR theImageFile: LONGINT): OSErr; C;}
    type
        GXOpenConnectionProcPtr = ProcPtr;  { FUNCTION GXOpenConnection: OSErr; }
        GXOpenConnectionUPP = UniversalProcPtr;

    const
        uppGXOpenConnectionProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXOpenConnectionProc (userRoutine: GXOpenConnectionProcPtr): GXOpenConnectionUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXOpenConnectionProc (userRoutine: GXOpenConnectionUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXOpenConnectionProc = GXOpenConnectionUPP;


{FUNCTION Send_GXOpenConnection: OSErr; C;}
{FUNCTION Forward_GXOpenConnection: OSErr; C;}
    type
        GXCloseConnectionProcPtr = ProcPtr;  { FUNCTION GXCloseConnection: OSErr; }
        GXCloseConnectionUPP = UniversalProcPtr;

    const
        uppGXCloseConnectionProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXCloseConnectionProc (userRoutine: GXCloseConnectionProcPtr): GXCloseConnectionUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCloseConnectionProc (userRoutine: GXCloseConnectionUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCloseConnectionProc = GXCloseConnectionUPP;


{FUNCTION Send_GXCloseConnection: OSErr; C;}
{FUNCTION Forward_GXCloseConnection: OSErr; C;}
    type
        GXStartSendPageProcPtr = ProcPtr;  { FUNCTION GXStartSendPage(theFormat: gxFormat): OSErr; }
        GXStartSendPageUPP = UniversalProcPtr;

    const
        uppGXStartSendPageProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXStartSendPageProc (userRoutine: GXStartSendPageProcPtr): GXStartSendPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXStartSendPageProc (theFormat: gxFormat; userRoutine: GXStartSendPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXStartSendPageProc = GXStartSendPageUPP;


{FUNCTION Send_GXStartSendPage(theFormat: gxFormat): OSErr; C;}
{FUNCTION Forward_GXStartSendPage(theFormat: gxFormat): OSErr; C;}
    type
        GXFinishSendPageProcPtr = ProcPtr;  { FUNCTION GXFinishSendPage: OSErr; }
        GXFinishSendPageUPP = UniversalProcPtr;

    const
        uppGXFinishSendPageProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXFinishSendPageProc (userRoutine: GXFinishSendPageProcPtr): GXFinishSendPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFinishSendPageProc (userRoutine: GXFinishSendPageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFinishSendPageProc = GXFinishSendPageUPP;


{FUNCTION Send_GXFinishSendPage: OSErr; C;}
{FUNCTION Forward_GXFinishSendPage: OSErr; C;}
    type
        GXWriteDataProcPtr = ProcPtr;  { FUNCTION GXWriteData(data: Ptr; length: LONGINT): OSErr; }
        GXWriteDataUPP = UniversalProcPtr;

    const
        uppGXWriteDataProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXWriteDataProc (userRoutine: GXWriteDataProcPtr): GXWriteDataUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXWriteDataProc (data: Ptr; length: LONGINT; userRoutine: GXWriteDataUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXWriteDataProc = GXWriteDataUPP;


{FUNCTION Send_GXWriteData(data: Ptr; length: LONGINT): OSErr; C;}
{FUNCTION Forward_GXWriteData(data: Ptr; length: LONGINT): OSErr; C;}
    type
        GXBufferDataProcPtr = ProcPtr;  { FUNCTION GXBufferData(data: Ptr; length: LONGINT; bufferOptions: LONGINT): OSErr; }
        GXBufferDataUPP = UniversalProcPtr;

    const
        uppGXBufferDataProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXBufferDataProc (userRoutine: GXBufferDataProcPtr): GXBufferDataUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXBufferDataProc (data: Ptr; length: LONGINT; bufferOptions: LONGINT; userRoutine: GXBufferDataUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXBufferDataProc = GXBufferDataUPP;


{FUNCTION Send_GXBufferData(data: Ptr; length: LONGINT; bufferOptions: LONGINT): OSErr; C;}
{FUNCTION Forward_GXBufferData(data: Ptr; length: LONGINT; bufferOptions: LONGINT): OSErr; C;}
    type
        GXDumpBufferProcPtr = ProcPtr;  { FUNCTION GXDumpBuffer(VAR theBuffer: gxPrintingBuffer): OSErr; }
        GXDumpBufferUPP = UniversalProcPtr;

    const
        uppGXDumpBufferProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXDumpBufferProc (userRoutine: GXDumpBufferProcPtr): GXDumpBufferUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDumpBufferProc (var theBuffer: gxPrintingBuffer; userRoutine: GXDumpBufferUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDumpBufferProc = GXDumpBufferUPP;


{FUNCTION Send_GXDumpBuffer(VAR theBuffer: gxPrintingBuffer): OSErr; C;}
{FUNCTION Forward_GXDumpBuffer(VAR theBuffer: gxPrintingBuffer): OSErr; C;}
    type
        GXFreeBufferProcPtr = ProcPtr;  { FUNCTION GXFreeBuffer(VAR theBuffer: gxPrintingBuffer): OSErr; }
        GXFreeBufferUPP = UniversalProcPtr;

    const
        uppGXFreeBufferProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXFreeBufferProc (userRoutine: GXFreeBufferProcPtr): GXFreeBufferUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFreeBufferProc (var theBuffer: gxPrintingBuffer; userRoutine: GXFreeBufferUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFreeBufferProc = GXFreeBufferUPP;


{FUNCTION Send_GXFreeBuffer(VAR theBuffer: gxPrintingBuffer): OSErr; C;}
{FUNCTION Forward_GXFreeBuffer(VAR theBuffer: gxPrintingBuffer): OSErr; C;}
    type
        GXCheckStatusProcPtr = ProcPtr;  { FUNCTION GXCheckStatus(data: Ptr; length: LONGINT; statusType: LONGINT; owner: gxOwnerSignature): OSErr; }
        GXCheckStatusUPP = UniversalProcPtr;

    const
        uppGXCheckStatusProcInfo = $00003FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXCheckStatusProc (userRoutine: GXCheckStatusProcPtr): GXCheckStatusUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCheckStatusProc (data: Ptr; length: LONGINT; statusType: LONGINT; owner: gxOwnerSignature; userRoutine: GXCheckStatusUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCheckStatusProc = GXCheckStatusUPP;


{FUNCTION Send_GXCheckStatus(data: Ptr; length: LONGINT; statusType: LONGINT; owner: gxOwnerSignature): OSErr; C;}
{FUNCTION Forward_GXCheckStatus(data: Ptr; length: LONGINT; statusType: LONGINT; owner: gxOwnerSignature): OSErr; C;}
    type
        GXGetDeviceStatusProcPtr = ProcPtr;  { FUNCTION GXGetDeviceStatus(cmdData: Ptr; cmdSize: LONGINT; responseData: Ptr; VAR responseSize: LONGINT; VAR termination: Str255): OSErr; }
        GXGetDeviceStatusUPP = UniversalProcPtr;

    const
        uppGXGetDeviceStatusProcInfo = $0000FFE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXGetDeviceStatusProc (userRoutine: GXGetDeviceStatusProcPtr): GXGetDeviceStatusUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXGetDeviceStatusProc (cmdData: Ptr; cmdSize: LONGINT; responseData: Ptr; var responseSize: LONGINT; var termination: Str255; userRoutine: GXGetDeviceStatusUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXGetDeviceStatusProc = GXGetDeviceStatusUPP;


{FUNCTION Send_GXGetDeviceStatus(cmdData: Ptr; cmdSize: LONGINT; responseData: Ptr; VAR responseSize: LONGINT; VAR termination: Str255): OSErr; C;}
{FUNCTION Forward_GXGetDeviceStatus(cmdData: Ptr; cmdSize: LONGINT; responseData: Ptr; VAR responseSize: LONGINT; VAR termination: Str255): OSErr; C;}
    type
        GXFetchTaggedDataProcPtr = ProcPtr;  { FUNCTION GXFetchTaggedData(theType: ResType; id: LONGINT; VAR dataHdl: Handle; owner: gxOwnerSignature): OSErr; }
        GXFetchTaggedDataUPP = UniversalProcPtr;

    const
        uppGXFetchTaggedDataProcInfo = $00003FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXFetchTaggedDataProc (userRoutine: GXFetchTaggedDataProcPtr): GXFetchTaggedDataUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFetchTaggedDataProc (theType: ResType; id: LONGINT; var dataHdl: Handle; owner: gxOwnerSignature; userRoutine: GXFetchTaggedDataUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFetchTaggedDataProc = GXFetchTaggedDataUPP;


{FUNCTION Send_GXFetchTaggedData(theType: ResType; id: LONGINT; VAR dataHdl: Handle; owner: gxOwnerSignature): OSErr; C;}
{FUNCTION Forward_GXFetchTaggedData(theType: ResType; id: LONGINT; VAR dataHdl: Handle; owner: gxOwnerSignature): OSErr; C;}
    type
        GXGetDTPMenuListProcPtr = ProcPtr;  { FUNCTION GXGetDTPMenuList(menuHdl: MenuHandle): OSErr; }
        GXGetDTPMenuListUPP = UniversalProcPtr;

    const
        uppGXGetDTPMenuListProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXGetDTPMenuListProc (userRoutine: GXGetDTPMenuListProcPtr): GXGetDTPMenuListUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXGetDTPMenuListProc (menuHdl: MenuHandle; userRoutine: GXGetDTPMenuListUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXGetDTPMenuListProc = GXGetDTPMenuListUPP;


{FUNCTION Send_GXGetDTPMenuList(menuHdl: MenuHandle): OSErr; C;}
{FUNCTION Forward_GXGetDTPMenuList(menuHdl: MenuHandle): OSErr; C;}
    type
        GXDTPMenuSelectProcPtr = ProcPtr;  { FUNCTION GXDTPMenuSelect(id: LONGINT): OSErr; }
        GXDTPMenuSelectUPP = UniversalProcPtr;

    const
        uppGXDTPMenuSelectProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXDTPMenuSelectProc (userRoutine: GXDTPMenuSelectProcPtr): GXDTPMenuSelectUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDTPMenuSelectProc (id: LONGINT; userRoutine: GXDTPMenuSelectUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDTPMenuSelectProc = GXDTPMenuSelectUPP;


{FUNCTION Send_GXDTPMenuSelect(id: LONGINT): OSErr; C;}
{FUNCTION Forward_GXDTPMenuSelect(id: LONGINT): OSErr; C;}
    type
        GXHandleAlertFilterProcPtr = ProcPtr;  { FUNCTION GXHandleAlertFilter(theJob: gxJob; VAR pStatusRec: gxStatusRecord; pDialog: DialogPtr; VAR theEvent: EventRecord; VAR itemHit: INTEGER; VAR returnImmed: BOOLEAN): OSErr; }
        GXHandleAlertFilterUPP = UniversalProcPtr;

    const
        uppGXHandleAlertFilterProcInfo = $0003FFE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXHandleAlertFilterProc (userRoutine: GXHandleAlertFilterProcPtr): GXHandleAlertFilterUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXHandleAlertFilterProc (theJob: gxJob; var pStatusRec: gxStatusRecord; pDialog: DialogPtr; var theEvent: EventRecord; var itemHit: INTEGER; var returnImmed: BOOLEAN; userRoutine: GXHandleAlertFilterUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXHandleAlertFilterProc = GXHandleAlertFilterUPP;


{FUNCTION Send_GXHandleAlertFilter(theJob: gxJob; VAR pStatusRec: gxStatusRecord; pDialog: DialogPtr; VAR theEvent: EventRecord; VAR itemHit: INTEGER; VAR returnImmed: BOOLEAN): OSErr; C;}
{FUNCTION Forward_GXHandleAlertFilter(theJob: gxJob; VAR pStatusRec: gxStatusRecord; pDialog: DialogPtr; VAR theEvent: EventRecord; VAR itemHit: INTEGER; VAR returnImmed: BOOLEAN): OSErr; C;}
    type
        GXJobFormatModeQueryProcPtr = ProcPtr;  { FUNCTION GXJobFormatModeQuery(theQuery: gxQueryType; srcData: UNIV Ptr; dstData: UNIV Ptr): OSErr; }
        GXJobFormatModeQueryUPP = UniversalProcPtr;

    const
        uppGXJobFormatModeQueryProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXJobFormatModeQueryProc (userRoutine: GXJobFormatModeQueryProcPtr): GXJobFormatModeQueryUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXJobFormatModeQueryProc (theQuery: gxQueryType; srcData: univ Ptr; dstData: univ Ptr; userRoutine: GXJobFormatModeQueryUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXJobFormatModeQueryProc = GXJobFormatModeQueryUPP;


{FUNCTION Send_GXJobFormatModeQuery(theQuery: gxQueryType; srcData: UNIV Ptr; dstData: UNIV Ptr): OSErr; C;}
{FUNCTION Forward_GXJobFormatModeQuery(theQuery: gxQueryType; srcData: UNIV Ptr; dstData: UNIV Ptr): OSErr; C;}
    type
        GXWriteStatusToDTPWindowProcPtr = ProcPtr;  { FUNCTION GXWriteStatusToDTPWindow(VAR pStatusRec: gxStatusRecord; VAR pDisplay: gxDisplayRecord): OSErr; }
        GXWriteStatusToDTPWindowUPP = UniversalProcPtr;

    const
        uppGXWriteStatusToDTPWindowProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXWriteStatusToDTPWindowProc (userRoutine: GXWriteStatusToDTPWindowProcPtr): GXWriteStatusToDTPWindowUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXWriteStatusToDTPWindowProc (var pStatusRec: gxStatusRecord; var pDisplay: gxDisplayRecord; userRoutine: GXWriteStatusToDTPWindowUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXWriteStatusToDTPWindowProc = GXWriteStatusToDTPWindowUPP;


{FUNCTION Send_GXWriteStatusToDTPWindow(VAR pStatusRec: gxStatusRecord; VAR pDisplay: gxDisplayRecord): OSErr; C;}
{FUNCTION Forward_GXWriteStatusToDTPWindow(VAR pStatusRec: gxStatusRecord; VAR pDisplay: gxDisplayRecord): OSErr; C;}
    type
        GXInitializeStatusAlertProcPtr = ProcPtr;  { FUNCTION GXInitializeStatusAlert(VAR pStatusRec: gxStatusRecord; VAR pDialog: DialogPtr): OSErr; }
        GXInitializeStatusAlertUPP = UniversalProcPtr;

    const
        uppGXInitializeStatusAlertProcInfo = $000003E1; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }

    function NewGXInitializeStatusAlertProc (userRoutine: GXInitializeStatusAlertProcPtr): GXInitializeStatusAlertUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXInitializeStatusAlertProc (var pStatusRec: gxStatusRecord; var pDialog: DialogPtr; userRoutine: GXInitializeStatusAlertUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXInitializeStatusAlertProc = GXInitializeStatusAlertUPP;


{FUNCTION Send_GXInitializeStatusAlert(VAR pStatusRec: gxStatusRecord; VAR pDialog: DialogPtr): OSErr; C;}
{FUNCTION Forward_GXInitializeStatusAlert(VAR pStatusRec: gxStatusRecord; VAR pDialog: DialogPtr): OSErr; C;}
    type
        GXHandleAlertStatusProcPtr = ProcPtr;  { FUNCTION GXHandleAlertStatus(VAR pStatusRec: gxStatusRecord): OSErr; }
        GXHandleAlertStatusUPP = UniversalProcPtr;

    const
        uppGXHandleAlertStatusProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXHandleAlertStatusProc (userRoutine: GXHandleAlertStatusProcPtr): GXHandleAlertStatusUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXHandleAlertStatusProc (var pStatusRec: gxStatusRecord; userRoutine: GXHandleAlertStatusUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXHandleAlertStatusProc = GXHandleAlertStatusUPP;


{FUNCTION Send_GXHandleAlertStatus(VAR pStatusRec: gxStatusRecord): OSErr; C;}
{FUNCTION Forward_GXHandleAlertStatus(VAR pStatusRec: gxStatusRecord): OSErr; C;}
    type
        GXHandleAlertEventProcPtr = ProcPtr;  { FUNCTION GXHandleAlertEvent(VAR pStatusRec: gxStatusRecord; pDialog: DialogPtr; VAR theEvent: EventRecord; VAR response: INTEGER): OSErr; }
        GXHandleAlertEventUPP = UniversalProcPtr;

    const
        uppGXHandleAlertEventProcInfo = $00003FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXHandleAlertEventProc (userRoutine: GXHandleAlertEventProcPtr): GXHandleAlertEventUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXHandleAlertEventProc (var pStatusRec: gxStatusRecord; pDialog: DialogPtr; var theEvent: EventRecord; var response: INTEGER; userRoutine: GXHandleAlertEventUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXHandleAlertEventProc = GXHandleAlertEventUPP;


{FUNCTION Send_GXHandleAlertEvent(VAR pStatusRec: gxStatusRecord; pDialog: DialogPtr; VAR theEvent: EventRecord; VAR response: INTEGER): OSErr; C;}
{FUNCTION Forward_GXHandleAlertEvent(VAR pStatusRec: gxStatusRecord; pDialog: DialogPtr; VAR theEvent: EventRecord; VAR response: INTEGER): OSErr; C;}
    type
        GXCleanupStartJobProcPtr = ProcPtr;  { PROCEDURE GXCleanupStartJob; }
        GXCleanupStartJobUPP = UniversalProcPtr;

    const
        uppGXCleanupStartJobProcInfo = $00000001; { PROCEDURE ; }

    function NewGXCleanupStartJobProc (userRoutine: GXCleanupStartJobProcPtr): GXCleanupStartJobUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    procedure CallGXCleanupStartJobProc (userRoutine: GXCleanupStartJobUPP);
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCleanupStartJobProc = GXCleanupStartJobUPP;


{PROCEDURE Send_GXCleanupStartJob; C;}
{PROCEDURE Forward_GXCleanupStartJob; C;}
    type
        GXCleanupStartPageProcPtr = ProcPtr;  { PROCEDURE GXCleanupStartPage; }
        GXCleanupStartPageUPP = UniversalProcPtr;

    const
        uppGXCleanupStartPageProcInfo = $00000001; { PROCEDURE ; }

    function NewGXCleanupStartPageProc (userRoutine: GXCleanupStartPageProcPtr): GXCleanupStartPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    procedure CallGXCleanupStartPageProc (userRoutine: GXCleanupStartPageUPP);
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCleanupStartPageProc = GXCleanupStartPageUPP;


{PROCEDURE Send_GXCleanupStartPage; C;}
{PROCEDURE Forward_GXCleanupStartPage; C;}
    type
        GXCleanupOpenConnectionProcPtr = ProcPtr;  { PROCEDURE GXCleanupOpenConnection; }
        GXCleanupOpenConnectionUPP = UniversalProcPtr;

    const
        uppGXCleanupOpenConnectionProcInfo = $00000001; { PROCEDURE ; }

    function NewGXCleanupOpenConnectionProc (userRoutine: GXCleanupOpenConnectionProcPtr): GXCleanupOpenConnectionUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    procedure CallGXCleanupOpenConnectionProc (userRoutine: GXCleanupOpenConnectionUPP);
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCleanupOpenConnectionProc = GXCleanupOpenConnectionUPP;


{PROCEDURE Send_GXCleanupOpenConnection; C;}
{PROCEDURE Forward_GXCleanupOpenConnection; C;}
    type
        GXCleanupStartSendPageProcPtr = ProcPtr;  { PROCEDURE GXCleanupStartSendPage; }
        GXCleanupStartSendPageUPP = UniversalProcPtr;

    const
        uppGXCleanupStartSendPageProcInfo = $00000001; { PROCEDURE ; }

    function NewGXCleanupStartSendPageProc (userRoutine: GXCleanupStartSendPageProcPtr): GXCleanupStartSendPageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    procedure CallGXCleanupStartSendPageProc (userRoutine: GXCleanupStartSendPageUPP);
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCleanupStartSendPageProc = GXCleanupStartSendPageUPP;


{PROCEDURE Send_GXCleanupStartSendPage; C;}
{PROCEDURE Forward_GXCleanupStartSendPage; C;}
    type
        GXDefaultDesktopPrinterProcPtr = ProcPtr;  { FUNCTION GXDefaultDesktopPrinter(VAR dtpName: Str31): OSErr; }
        GXDefaultDesktopPrinterUPP = UniversalProcPtr;

    const
        uppGXDefaultDesktopPrinterProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXDefaultDesktopPrinterProc (userRoutine: GXDefaultDesktopPrinterProcPtr): GXDefaultDesktopPrinterUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDefaultDesktopPrinterProc (var dtpName: Str31; userRoutine: GXDefaultDesktopPrinterUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDefaultDesktopPrinterProc = GXDefaultDesktopPrinterUPP;


{FUNCTION Send_GXDefaultDesktopPrinter(VAR dtpName: Str31): OSErr; C;}
{FUNCTION Forward_GXDefaultDesktopPrinter(VAR dtpName: Str31): OSErr; C;}
    type
        GXCaptureOutputDeviceProcPtr = ProcPtr;  { FUNCTION GXCaptureOutputDevice(capture: BOOLEAN): OSErr; }
        GXCaptureOutputDeviceUPP = UniversalProcPtr;

    const
        uppGXCaptureOutputDeviceProcInfo = $00000061; { FUNCTION (1 byte param): 2 byte result; }

    function NewGXCaptureOutputDeviceProc (userRoutine: GXCaptureOutputDeviceProcPtr): GXCaptureOutputDeviceUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXCaptureOutputDeviceProc (capture: BOOLEAN; userRoutine: GXCaptureOutputDeviceUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXCaptureOutputDeviceProc = GXCaptureOutputDeviceUPP;


{FUNCTION Send_GXCaptureOutputDevice(capture: BOOLEAN): OSErr; C;}
{FUNCTION Forward_GXCaptureOutputDevice(capture: BOOLEAN): OSErr; C;}
    type
        GXOpenConnectionRetryProcPtr = ProcPtr;  { FUNCTION GXOpenConnectionRetry(theType: ResType; aVoid: UNIV Ptr; VAR retryopenPtr: BOOLEAN; anErr: OSErr): OSErr; }
        GXOpenConnectionRetryUPP = UniversalProcPtr;

    const
        uppGXOpenConnectionRetryProcInfo = $00002FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 2 byte param): 2 byte result; }

    function NewGXOpenConnectionRetryProc (userRoutine: GXOpenConnectionRetryProcPtr): GXOpenConnectionRetryUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXOpenConnectionRetryProc (theType: ResType; aVoid: univ Ptr; var retryopenPtr: BOOLEAN; anErr: OSErr; userRoutine: GXOpenConnectionRetryUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXOpenConnectionRetryProc = GXOpenConnectionRetryUPP;


{FUNCTION Send_GXOpenConnectionRetry(theType: ResType; aVoid: UNIV Ptr; VAR retryopenPtr: BOOLEAN; anErr: OSErr): OSErr; C;}
{FUNCTION Forward_GXOpenConnectionRetry(theType: ResType; aVoid: UNIV Ptr; VAR retryopenPtr: BOOLEAN; anErr: OSErr): OSErr; C;}
    type
        GXExamineSpoolFileProcPtr = ProcPtr;  { FUNCTION GXExamineSpoolFile(theSpoolFile: gxSpoolFile): OSErr; }
        GXExamineSpoolFileUPP = UniversalProcPtr;

    const
        uppGXExamineSpoolFileProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXExamineSpoolFileProc (userRoutine: GXExamineSpoolFileProcPtr): GXExamineSpoolFileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXExamineSpoolFileProc (theSpoolFile: gxSpoolFile; userRoutine: GXExamineSpoolFileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXExamineSpoolFileProc = GXExamineSpoolFileUPP;


{FUNCTION Send_GXExamineSpoolFile(theSpoolFile: gxSpoolFile): OSErr; C;}
{FUNCTION Forward_GXExamineSpoolFile(theSpoolFile: gxSpoolFile): OSErr; C;}
    type
        GXFinishSendPlaneProcPtr = ProcPtr;  { FUNCTION GXFinishSendPlane: OSErr; }
        GXFinishSendPlaneUPP = UniversalProcPtr;

    const
        uppGXFinishSendPlaneProcInfo = $00000021; { FUNCTION : 2 byte result; }

    function NewGXFinishSendPlaneProc (userRoutine: GXFinishSendPlaneProcPtr): GXFinishSendPlaneUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFinishSendPlaneProc (userRoutine: GXFinishSendPlaneUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFinishSendPlaneProc = GXFinishSendPlaneUPP;


{FUNCTION Send_GXFinishSendPlane: OSErr; C;}
{FUNCTION Forward_GXFinishSendPlane: OSErr; C;}
    type
        GXDoesPaperFitProcPtr = ProcPtr;  { FUNCTION GXDoesPaperFit(whichTray: gxTrayIndex; paper: gxPaperType; VAR fits: BOOLEAN): OSErr; }
        GXDoesPaperFitUPP = UniversalProcPtr;

    const
        uppGXDoesPaperFitProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXDoesPaperFitProc (userRoutine: GXDoesPaperFitProcPtr): GXDoesPaperFitUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXDoesPaperFitProc (whichTray: gxTrayIndex; paper: gxPaperType; var fits: BOOLEAN; userRoutine: GXDoesPaperFitUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXDoesPaperFitProc = GXDoesPaperFitUPP;


{FUNCTION Send_GXDoesPaperFit(whichTray: gxTrayIndex; paper: gxPaperType; VAR fits: BOOLEAN): OSErr; C;}
{FUNCTION Forward_GXDoesPaperFit(whichTray: gxTrayIndex; paper: gxPaperType; VAR fits: BOOLEAN): OSErr; C;}
    type
        GXChooserMessageProcPtr = ProcPtr;  { FUNCTION GXChooserMessage(message: LONGINT; caller: LONGINT; objName: StringPtr; zoneName: StringPtr; theList: ListHandle; p2: LONGINT): OSErr; }
        GXChooserMessageUPP = UniversalProcPtr;

    const
        uppGXChooserMessageProcInfo = $0003FFE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXChooserMessageProc (userRoutine: GXChooserMessageProcPtr): GXChooserMessageUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXChooserMessageProc (message: LONGINT; caller: LONGINT; objName: StringPtr; zoneName: StringPtr; theList: ListHandle; p2: LONGINT; userRoutine: GXChooserMessageUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXChooserMessageProc = GXChooserMessageUPP;


{FUNCTION Send_GXChooserMessage(message: LONGINT; caller: LONGINT; objName: StringPtr; zoneName: StringPtr; theList: ListHandle; p2: LONGINT): OSErr; C;}
{FUNCTION Forward_GXChooserMessage(message: LONGINT; caller: LONGINT; objName: StringPtr; zoneName: StringPtr; theList: ListHandle; p2: LONGINT): OSErr; C;}
    type
        GXFindPrinterProfileProcPtr = ProcPtr;  { FUNCTION GXFindPrinterProfile(thePrinter: gxPrinter; searchData: UNIV Ptr; index: LONGINT; VAR returnedProfile: gxColorProfile; VAR numProfiles: LONGINT): OSErr; }
        GXFindPrinterProfileUPP = UniversalProcPtr;

    const
        uppGXFindPrinterProfileProcInfo = $0000FFE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXFindPrinterProfileProc (userRoutine: GXFindPrinterProfileProcPtr): GXFindPrinterProfileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFindPrinterProfileProc (thePrinter: gxPrinter; searchData: univ Ptr; index: LONGINT; var returnedProfile: gxColorProfile; var numProfiles: LONGINT; userRoutine: GXFindPrinterProfileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFindPrinterProfileProc = GXFindPrinterProfileUPP;


{FUNCTION Send_GXFindPrinterProfile(thePrinter: gxPrinter; searchData: UNIV Ptr; index: LONGINT; VAR returnedProfile: gxColorProfile; VAR numProfiles: LONGINT): OSErr; C;}
{FUNCTION Forward_GXFindPrinterProfile(thePrinter: gxPrinter; searchData: UNIV Ptr; index: LONGINT; VAR returnedProfile: gxColorProfile; VAR numProfiles: LONGINT): OSErr; C;}
    type
        GXFindFormatProfileProcPtr = ProcPtr;  { FUNCTION GXFindFormatProfile(theFormat: gxFormat; searchData: UNIV Ptr; index: LONGINT; VAR returnedProfile: gxColorProfile; VAR numProfiles: LONGINT): OSErr; }
        GXFindFormatProfileUPP = UniversalProcPtr;

    const
        uppGXFindFormatProfileProcInfo = $0000FFE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXFindFormatProfileProc (userRoutine: GXFindFormatProfileProcPtr): GXFindFormatProfileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXFindFormatProfileProc (theFormat: gxFormat; searchData: univ Ptr; index: LONGINT; var returnedProfile: gxColorProfile; var numProfiles: LONGINT; userRoutine: GXFindFormatProfileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXFindFormatProfileProc = GXFindFormatProfileUPP;


{FUNCTION Send_GXFindFormatProfile(theFormat: gxFormat; searchData: UNIV Ptr; index: LONGINT; VAR returnedProfile: gxColorProfile; VAR numProfiles: LONGINT): OSErr; C;}
{FUNCTION Forward_GXFindFormatProfile(theFormat: gxFormat; searchData: UNIV Ptr; index: LONGINT; VAR returnedProfile: gxColorProfile; VAR numProfiles: LONGINT): OSErr; C;}
    type
        GXSetPrinterProfileProcPtr = ProcPtr;  { FUNCTION GXSetPrinterProfile(thePrinter: gxPrinter; oldProfile: gxColorProfile; newProfile: gxColorProfile): OSErr; }
        GXSetPrinterProfileUPP = UniversalProcPtr;

    const
        uppGXSetPrinterProfileProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXSetPrinterProfileProc (userRoutine: GXSetPrinterProfileProcPtr): GXSetPrinterProfileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXSetPrinterProfileProc (thePrinter: gxPrinter; oldProfile: gxColorProfile; newProfile: gxColorProfile; userRoutine: GXSetPrinterProfileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXSetPrinterProfileProc = GXSetPrinterProfileUPP;


{FUNCTION Send_GXSetPrinterProfile(thePrinter: gxPrinter; oldProfile: gxColorProfile; newProfile: gxColorProfile): OSErr; C;}
{FUNCTION Forward_GXSetPrinterProfile(thePrinter: gxPrinter; oldProfile: gxColorProfile; newProfile: gxColorProfile): OSErr; C;}
    type
        GXSetFormatProfileProcPtr = ProcPtr;  { FUNCTION GXSetFormatProfile(theFormat: gxFormat; oldProfile: gxColorProfile; newProfile: gxColorProfile): OSErr; }
        GXSetFormatProfileUPP = UniversalProcPtr;

    const
        uppGXSetFormatProfileProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXSetFormatProfileProc (userRoutine: GXSetFormatProfileProcPtr): GXSetFormatProfileUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXSetFormatProfileProc (theFormat: gxFormat; oldProfile: gxColorProfile; newProfile: gxColorProfile; userRoutine: GXSetFormatProfileUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXSetFormatProfileProc = GXSetFormatProfileUPP;


{FUNCTION Send_GXSetFormatProfile(theFormat: gxFormat; oldProfile: gxColorProfile; newProfile: gxColorProfile): OSErr; C;}
{FUNCTION Forward_GXSetFormatProfile(theFormat: gxFormat; oldProfile: gxColorProfile; newProfile: gxColorProfile): OSErr; C;}
    type
        GXHandleAltDestinationProcPtr = ProcPtr;  { FUNCTION GXHandleAltDestination(VAR userCancels: BOOLEAN): OSErr; }
        GXHandleAltDestinationUPP = UniversalProcPtr;

    const
        uppGXHandleAltDestinationProcInfo = $000000E1; { FUNCTION (4 byte param): 2 byte result; }

    function NewGXHandleAltDestinationProc (userRoutine: GXHandleAltDestinationProcPtr): GXHandleAltDestinationUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXHandleAltDestinationProc (var userCancels: BOOLEAN; userRoutine: GXHandleAltDestinationUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXHandleAltDestinationProc = GXHandleAltDestinationUPP;


{FUNCTION Send_GXHandleAltDestination(VAR userCancels: BOOLEAN): OSErr; C;}
{FUNCTION Forward_GXHandleAltDestination(VAR userCancels: BOOLEAN): OSErr; C;}
    type
        GXSetupPageImageDataProcPtr = ProcPtr;  { FUNCTION GXSetupPageImageData(theFormat: gxFormat; thePage: gxShape; imageData: UNIV Ptr): OSErr; }
        GXSetupPageImageDataUPP = UniversalProcPtr;

    const
        uppGXSetupPageImageDataProcInfo = $00000FE1; { FUNCTION (4 byte param, 4 byte param, 4 byte param): 2 byte result; }

    function NewGXSetupPageImageDataProc (userRoutine: GXSetupPageImageDataProcPtr): GXSetupPageImageDataUPP;
    {$IFC NOT GENERATINGCFM }
    inline
        $2E9F;
    {$ENDC}

    function CallGXSetupPageImageDataProc (theFormat: gxFormat; thePage: gxShape; imageData: univ Ptr; userRoutine: GXSetupPageImageDataUPP): OSErr;
    {$IFC NOT GENERATINGCFM}
    inline
        $205F, $4E90;
    {$ENDC}

    type
        GXSetupPageImageDataProc = GXSetupPageImageDataUPP;


{FUNCTION Send_GXSetupPageImageData(theFormat: gxFormat; thePage: gxShape; imageData: UNIV Ptr): OSErr; C;}
{FUNCTION Forward_GXSetupPageImageData(theFormat: gxFormat; thePage: gxShape; imageData: UNIV Ptr): OSErr; C;}
{******************************************************************}
{                    Start of old "GXPrintingErrors.h/a/p" interface file.}
{            *******************************************************************}

    const
        gxPrintingResultBase = -510;                            {First QuickDraw GX printing error code.}

{RESULT CODES FOR QUICKDRAW GX PRINTING OPERATIONS}
        gxAioTimeout = -510;        {-510 : Timeout condition occurred during operation}
        gxAioBadRqstState = -511;    {-511 : Async I/O request in invalid state for operation}
        gxAioBadConn = -512;    {-512 : Invalid Async I/O connection refnum}
        gxAioInvalidXfer = -513;    {-513 : Read data transfer structure contained bad values}
        gxAioNoRqstBlks = -514;    {-514 : No available request blocks to process request}
        gxAioNoDataXfer = -515;    {-515 : Data transfer structure pointer not specified}
        gxAioTooManyAutos = -516;    {-516 : Auto status request already active}
        gxAioNoAutoStat = -517;    {-517 : Connection not configured for auto status}
        gxAioBadRqstID = -518;    {-518 : Invalid I/O request identifier}
        gxAioCantKill = -519;    {-519 : Comm. protocol doesn't support I/O term}
        gxAioAlreadyExists = -520; {-520 : Protocol spec. data already specified}
        gxAioCantFind = -521; {-521 : Protocol spec. data does not exist}
        gxAioDeviceDisconn = -522; {-522 : Machine disconnected from printer}
        gxAioNotImplemented = -523; {-523 : Function not implemented}
        gxAioOpenPending = -524; {-524 : Opening a connection for protocol, but another open pending}
        gxAioNoProtocolData = -525; {-525 : No protocol specific data specified in request}
        gxAioRqstKilled = -526; {-526 : I/O request was terminated}
        gxBadBaudRate = -527; {-527 : Invalid baud rate specified}
        gxBadParity = -528; {-528 : Invalid parity specified}
        gxBadStopBits = -529; {-529 : Invalid stop bits specified}
        gxBadDataBits = -530; {-530 : Invalid data bits specified}
        gxBadPrinterName = -531; {-531 : Bad printer name specified}
        gxAioBadMsgType = -532; {-532 : Bad masType field in transfer info structure}
        gxAioCantFindDevice = -533; {-533 : Cannot locate target device}
        gxAioOutOfSeq = -534; {-534 : Non-atomic SCSI requests submitted out of sequence}
        gxPrIOAbortErr = -535; {-535 : I/O operation aborted}
        gxPrUserAbortErr = -536; {-536 : User aborted}
        gxCantAddPanelsNowErr = -537; {-537 : Can only add panels during driver switch or dialog setup}
        gxBadxdtlKeyErr = -538; {-538 : Unknown key for xdtl - must be radiobutton, etc}
        gxXdtlItemOutOfRangeErr = -539; {-539 : Referenced item does not belong to panel}
        gxNoActionButtonErr = -540; {-540 : Action button is nil}
        gxTitlesTooLongErr = -541; {-541 : Length of buttons exceeds alert maximum width}
        gxUnknownAlertVersionErr = -542; {-542 : Bad version for printing alerts}
        gxGBBufferTooSmallErr = -543; {-543 : Buffer too small.}
        gxInvalidPenTable = -544; {-544 : Invalid vector driver pen table.}
        gxIncompletePrintFileErr = -545; {-545 : Print file was not completely spooled}
        gxCrashedPrintFileErr = -546; {-546 : Print file is corrupted}
        gxInvalidPrintFileVersion = -547; {-547 : Print file is incompatible with current QuickDraw GX version}
        gxSegmentLoadFailedErr = -548; {-548 : Segment loader error}
        gxExtensionNotFoundErr = -549; {-549 : Requested printing extension could not be found}
        gxDriverVersionErr = -550; {-550 : Driver too new for current version of QuickDraw GX}
        gxImagingSystemVersionErr = -551; {-551 : Imaging system too new for current version of QuickDraw GX}
        gxFlattenVersionTooNew = -552; {-552 : Flattened object format too new for current version of QDGX}
        gxPaperTypeNotFound = -553; {-553 : Requested papertype could not be found}
        gxNoSuchPTGroup = -554; {-554 : Requested papertype group could not be found}
        gxNotEnoughPrinterMemory = -555; {-555 : Printer does not have enough memory for fonts in document}
        gxDuplicatePanelNameErr = -556; {-556 : Attempt to add more than 10 panels with the same name}
        gxExtensionVersionErr = -557; {-557 : Extension too new for current version of QuickDraw GX}


{ $ALIGN RESET}
{ $POP}

{$ENDC}
 {__GXPRINTING__}

implementation
end.